Alters

Mundo exterior: Matemáticas - Tema II (Representación de funciones con dos variables)

Buenas!

Seguimos con las "mates"; pero antes, un pequeño inciso (como viene siendo costumbre últimamente).

Ya le he dado uso a mi disco duro externo: he colocado todas las distro que uso, he usado y (en un futuro) usaré. Dejo la lista:
  • Hiren's Boot 15
  • WifiWay 3.4
  • AVG Rescue CD
  • Dr.Web Live CD
  • Kaspersky Rescue Disk
  • BackTrak 5
  • Ophcrack XP
  • Ophcrack Vista/7
  • Partition wizard
  • Linux Mint Mate x86
  • Helix3 R1
Y, aparte, tengo destinado un futuro emplazamiento para mis tablas rainbow y demás (capturas de tráfico, informes...) jejeje.

En fin, sigamos con las matemáticas: en esta entrada veremos la representación de funciones de dos variables.

Para ello, distinguiremos dos tipos de funciones:
 - Cónicas
 - No cónicas

Empecemos con el primer tipo:

Cónicas:

Las funciones cónicas tienen la siguiente forma:

f(x, y) = Ax2 + By2 + Cxy + Dx + Ey + F = 0

El término "Cxy" determina la orientación de la función: si "C" vale 0, los ejes de la cónica serán rectos.

No cónicas:

A riesgo de parecer muy obvio, si no cumple la forma anterior, no es cónica...

De momento, pasaremos a otro punto importante, para luego retomar la identificación de las cónicas. Hablemos ahora de los dominios de las funciones.

El dominio de una función de dos variables es una función tal que convierte el espacio R2 en R. En esta "transformación", tenemos que evaluar (pues pueden resultar conflictivos) una serie de casos, a saber: 
  • A / B => si B = 0
  • √A => si A < 0
  • Ln(A) => si a <= 0
  • arcsin(A) => si |A| >= 1
Como vemos, son casos problemáticos, pues producen "fallo" en los cálculos. Así, el análisis de dominio de una función se basará en estos puntos. Vamos con un ejemplo:

f(x, y) = sqrt((x2 – y2 + 4) / ((x – 1)2 + y2 – 9)) (sqrt() = raíz cuadrada)

He coloreado los paréntesis para que se puedan distinguir fácilmente. Veamos qué casos son "peligrosos" para la evaluación de esta función:

a) ((x – 1)2 + y2 – 9) = 0
b) (x2 – y2 + 4) / ((x – 1)2 + y2 – 9) < 0

Vamos a justificar ambos casos:

 - Si la expresión "a" se cumple, se haría una división por 0, por lo que de la raíz cuadrada ni hablamos.
 - Si la expresión "b" se cumple, no podemos hacer  la raíz cuadrada (al menos dentro del cuerpo de los reales, que es donde trabajamos)

El procedimiento para evaluar estas anomalías creo que será conocido: miramos qué condiciones hay que cumplir para que pase:

a) ((x – 1)2 + y2= 9

Si se cumple esto, tendríamos un problema. Vemos que la función de arriba define una circunferencia caracterizada por los siguientes datos:

 * Origen: (-1, 0)
 * Radio: 3 (sqrt(9))

Para los que no sepáis de donde viene esto, un inciso: la función que define una circunferencia es la siguiente:

f(x, y) = (x+a)^2 + (y+b)^2 = c

De aquí obtenemos:

 * Origen: (a, b)
 * Radio: sqrt(c)


b) Se divide en dos:

b1) ((x – 1)2 + y2= 9 (ya resuelta)
b2) (x2 – y2) = -4 => ±sqrt(x2 + 4) = y => y = ±(x+2)

La solución de "b2" es una fórmula de circunferencia, pero con "c" negativo (por lo que es, en realidad, una parábola doble).

Para no abusar tanto del escaneo de apuntes, voy a echar mano de mi amigo "Corel" para ilustrar un poco el panorama: 
















Si representamos ambas soluciones, quedan delimitadas 7 zonas, marcadas arriba. Del mismo modo que en la entrada anterior, comprobamos el signo de las ecuaciones "a" y "b" y calculamos su "total".

En este caso, nos interesan las zonas que sean mayores que 0 (positivas), ya que a fin de cuentas tendremos que hacer una raíz cuadrada.

Diríamos, en este caso, que la función solo tiene dominio en las zonas 2, 3, 5, y 6.

Una vez visto un ejemplo de aplicación de dominio, volvamos a las cónicas.

Identificación de cónicas:

f(x, y) = Ax2 + By2 + Cxy + Dx + Ey + F = 0 (suponemos "C" = 0)

Pongamos un ejemplo:


4x2y2 + 3x + 2y – 25 = 0
(2x + ¾)2 – 9/4(y2 – 2y) – 25 = 0
(2x + ¾)2 – 9/4[(y – 1)2 - 1] – 25 = 0
(2x + ¾)2(y – 1)2 = 105/4

Vamos a explicar un poco cómo llegamos a la forma de abajo (antes os comentaba que era la función que define una circunferencia).

Paso 1: Tenemos la ecuación tal cual
Paso 2: Agrupamos los términos con "x" (marcados en rojo), y factorizamos. Agrupamos también los términos con "y" (marcados de azul verdoso)
Paso 3: nos valemos de la siguiente expresión inmediata para ejercer el cambio sobre los términos "y":

(ax + b)2 = a2x2 + 2abx + b2

Ya que se cumple, podemos sustituir.

Paso 4: Despejamos para dejar en forma de "circunferencia".

Ahora bien, una vez tenemos nuestra ecuación "arreglada", tenemos que ver varias cosas:

Si sig("A") != sig("B") => hipérbola
Si sig("A") = sig("B") => elipse o circunferencia (puede ser imaginaria)

"sig()" es una función que obtiene el signo del coeficiente especificado.

Si tenemos una circunferencia es fácil dibujarla (buscamos el centro y usamos el radio); si es una hipérbola,  una elipse, o en general, procedemos así:
  • Buscamos el centro
  • Buscamos los puntos "x" e "y" en el centro
  • Dibujamos los puntos
Vamos por partes, con una versión un poco diferente al ejemplo anterior ((2x + ¾)2 + (y – 1)2 = 105/4):

Obtener el centro:

Para ello, tomamos parte de la ecuación (la correspondiente a cada variable, sin cuadrado) y la igualamos a 0, tal que: 

2x + 3/4 = 0 => x = -3/8
y - 1 = 0 => y = 1

Obtenemos nuestro punto (-3/8, 1), que es el centro.


Puntos "x" e "y" en el centro

Usando los valores del centro, resolvemos la ecuación correspondiente a la variable contraria, usando el cuadrado, tal que: 

(para x = -3/8): (y - 1)= 105/4; y = 1±sqrt(105/4)
(para y = 1): (2x + 3/4)= 105/4; x = (±sqrt(105/4) - 3/4)/2

y obtenemos estas dos expresiones: 

x = (±sqrt(105/4) - 3/4)/2
y = 1±sqrt(105/4)

Que usaríamos para dibujar (en este caso) nuestra elipse.

En el caso anterior (con los términos restando) obtenemos que en "y" no hay punto aplicable (ya que queda "y = 1±sqrt(-105/4)", y no hay solución real para ello), y "x" queda igual.

Con esto acabamos por esta vez. La próxima entrada tratará de curvas de nivel, gradientes y demás cosas similares (mis apuntes tienen una estructura un poco caótica... jejeje).

Como siempre, ¡Nos vemos!


Mundo exterior: Matemáticas - Tema II (Inecuaciones)

Buenas!

Llevaba tiempo sin escribir... en parte es "buena señal", ya que eso indica que hay algunos cambios.

Y sobre eso hablaremos antes de meternos de lleno en las matemáticas (funciones de diversas variables).

Siendo concretos, hay dos temas a comentar:

a) Un par de cambios
b) Un nuevo hilo "bloguero" a raíz de los cambios anteriores.

a) Ayer (jueves 25/abril) se celebró en mi ciudad el campeonato local de Robocode. Para el que no conozca este proyecto, lo explico brevemente:

Tomas un código fuente JAVA (también está la versión en C, que aún no he probado), y con él programas un tanque (robot). Esta programación no se basa en eventos interactivos (es decir, no lo tripulas, simplemente lo "sueltas" en el campo de batalla), sino en eventos a tiempo real. Principalmente hay cuatro interacciones que hacen saltar estos eventos:

 - El tanque choca contra una pared
 - El tanque choca contra otro tanque
 - El tanque es golpeado por una bala
 - El tanque detecta otro tanque

En base a estos eventos podemos "decirle" al tanque que haga ciertas cosas, como, por ejemplo:

"Cuando detectes otro tanque, dispara".

Obviamente, en JAVA, usando la API de Robocode.

Pues bien, me presenté, así como en la anterior edición (en la que gané en el sector individual), y este año si bien no rasqué nada en individual sí que quedé subcampeón en la modalidad de equipos (un grupo de 5 tanques programados por una persona).

Y me llevé como premio un disco duro externo WD passport de 2tb con conexión USB 3.0

De momento su uso está siendo pensado, ya que en casa tengo otro disco externo de 2tb...

b) Dejaré en la lista de hilos un tema dedicado a mi próxima creación para el próximo campeonato de Robocode.

Es decir, documentaré desde el inicio de la idea (ya en mi cabeza) hasta las clases JAVA que use.

Y bien, vayamos ahora a las matemáticas!

Entramos en el tema II, funciones de diversas variables.

En esta entrada veremos (de momento) las inecuaciones, a modo de introducción.

Antes de entrar en temario, vamos a definir formalmente una función:

f: Rn  à Rm

Es decir, toman un espacio de Rn (véase tema anterior) y lo adaptan a Rm. Ni "n" ni "m" tienen por que ser iguales o siquiera guardar un orden específico.

Ahora si, vayamos a las inecuaciones.

¿Qué es una inecuación?

Es una desigualdad que marca una relación entre valores conocidos y valores desconocidos. Un ejemplo:

2x - 4 > (2/3) - 7x

Vamos a resolverla:

[Pasamos -7x de un lado al otro como +7x, mientras que -4 lo pasamos como +12/3 a la otra parte]

9x > 14/3

x > 14/27

Como se puede apreciar, no es más que un poco de sentido común y aplicar las reglas de las ecuaciones. Amén de tener en cuenta una serie de cosas:


  • No simplificar ninguna variable
  • No multiplicar por "X" (o "Y", o ...)
  • No dividir por "X" (...)
  • Mantener las proporciones (hemos de tener en cuenta que al ser inecuaciones, hemos de vigilar que se mantenga la desigualdad)
La inecuación que hemos visto antes era una simple (1º grado). Vamos ahora con las inecuaciones de 2º grado:

x2 + x >2
x2 + x – 2 > 0
x2 + x – 2 = 0
x = 1; x = -2

Expliquemos:

Primero "inigualamos" a 0. Una vez hecho, lo pasamos a una ecuación de 2º grado normal, y calculamos los valores de X. De ahí obtendremos lo que llamaremos "puntos de corte". Lo podemos representar así:


Vemos tres zonas: rojo, azul, y verde. La primera y la tercera toman valores positivos (>0), y ya que lo que buscamos es una x tal que sea positiva, podemos concluir que la solución a la inecuación es el conjunto:

(-∞, -2)U(1, +∞)

Con este concepto claro, vayamos ahora un paso más allá: inecuaciones racionales. Como antes, un ejemplo que lo ilustre:

(x2 + x) / (x + 3) >= 2
((x2 + x) / (x + 3)) – 2 >= 0
(x2 - x - 6) / (x + 3) >= 0

a) x2 - x – 6 = 0
x = 3;x = -2

b) x+ 3 = 0
x = -3

Expliquemos: 

Dejamos "desigualado" a 0 (como antes). Una vez hecho, intentamos simplificar (en este caso, hemos "subido" el 2 multiplicado por "x+3" y lo hemos sumado al numerador). Ahora solo nos falta igualar tanto el numerador como el denominador a 0; esto nos dará dos ecuaciones que podemos calcular, obteniendo dos juegos de soluciones ("a" y "b").

De nuevo, tenemos más puntos de corte. En este caso, algo así:

Vamos a explicar esta confusión de números, colores y líneas:

La franja de arriba corresponde a la ecuación del numerador; la de arriba al denominador. En ambas están marcados los cambios de signos. A saber:

Numerador: Rojo > 0, azul < 0, violeta > 0
Denominador: Naranja < 0, verde > 0

Las líneas grises que cruzan ambas zonas son las soluciones anteriores (-3, -2, y 3). Esto crea cuatro zonas "comunes", que serán sobre las que calcularemos la solución.

Para saber el signo de estas zonas, tenemos que "sumar" (usando la ley de los signos) los resultados obtenidos en las zonas de cada ecuación.

Ya que la primera zona (la de más a la izquierda) es "positivo + negativo", obtenemos "negativo". Vamos haciendo para las cuatro zonas.

Así, ya que buscamos un "x >= 0", podemos concluir que la solución es:

(-3, -2] U [3, ∞)

A continuación, quedan dos pasos de dificultad, que veremos a la vez (escaneado de mis viejos apuntes):

 - Inecuaciones don dos variables
 - Inecuaciones de 2º grado con dos variables







































El procedimiento para resolver ambas es similar al anterior:

"Desigualamos" a 0, pasamos a ecuación normal, despejamos "y", y usamos el resultado como una función (f(x)). Seguidamente representamos la función, la cual nos delimita las zonas (así como antes eran líneas, ahora son funciones). Basta con tomar vectores (a, b) estratégicamente para saber el signo de las zonas, para obtener la zona que nos pida la inecuación.

Y con esto tenemos cubierta la primera parte del tema II.

Como siempre, ¡Hasta la próxima!

Interludio

Buenas!

De nuevo por aquí...

Acabada está ya la primera parte de nuestro remote tools... la próxima será, por tanto, matemáticas (tema II, ya).

Pero antes, hay varias cosas que anunciar.

a) Se ve a la vista un nuevo blog personal
b) Surgieron varios temas durante la pasada sección que dejo en cola. A saber:
  b1) Criptología
  b2) Hacking wifi
  b3) Obtención de datos
c) He desarrollado una pequeña función JS/HTML para blogger (lo veremos más abajo)
d) Tengo un nuevo "juguete" del que escribir
e) Hay un pequeño cambio (¡por fin!)

Así que vamos por partes.

Blog personal:

Pues eso... estoy pensando en hacer un pequeño blog donde meter todos mis pensamientos y textos... a ver si podemos fomentar la escritura y el pensamiento (al menos lo intentaré). Os mantendré informados, y, como siempre, si me decido, lo encontraréis más allá de los confines de mi blog.

Temas:

Éstos - y otros que quizás salen durante este tiempo - los guardo en mi pila de ToDo's de mi despacho (tengo un corcho bien grande lleno de papelitos con ideas...)

Función JS/HTML:

Bien, he creado una pequeña galería fotográfica (pensada para el blog de cosplay). Es una de las cosas que blogger no acaba de hacer: al subir varias fotos cuesta cuadrarlas (salen casi siempre una abajo de otra, y cosas así), así que cuando tengo que poner varias queda bastante "cutre".

Así que me estrujé el cerebro, y como soy tan y tan escéptico, no quise coger galerías de terceras personas, sino más bien hacerme una para mi (que de eso va este blog, ¿no?, ¡DIY!).

Y me gustaría compartir con vosotros mi aporte. Por tanto, vamos a ir paso a paso para ver cómo funciona la pequeña galería.

Para empezar, dejo un esquema general de cómo está estructurada la galería:


Para la notación usaré la siguiente convención (ejemplos):

elemento.clase

elemento#id

elemento.clase subelemento#id:estado

El elemento "global" es "div.blogMarquee". Dentro tenemos tres elementos: "div.blogMarqueePhoto", "marquee#bm" y "div.blogMarqueeScroll".

Dentro del primero hay un elemento: "img#cp".

Dentro del segundo están las imágenes, es decir, un conjunto de "marquee#bm img".

Dentro del tercer elemento hay dos "div": "div#bMSL" y "div#bMSR"

El contenido de "marquee#bm" lo tendremos que introducir de manera manual, y será lo único que varíe de una entrada a otra (es decir, la estructura es siempre la misma, solo cambiaremos las imágenes).

Igual os preguntáis que es eso de "marquee". Para los que no hayan usado nunca este elemento NO ESTÁNDAR de HTML decir que es, de manera general, un div cuyo contenido se mueve. De este movimiento podemos definir:

  • Velocidad
  • Frecuencia de movimiento
  • Dirección de movimiento
  • Modo de movimiento
  • Cantidad de ciclos de movimiento
Cuando veamos el código explicaré un poco más cómo funciona.

Entonces, el funcionamiento es el siguente:

 - Las imágenes pasan por "marquee#bm".

 - Al pasar por encima de "marquee#bm", el movimiento cesa, y se muestran flechas de dirección ("div#bMSL" y "div#bMSR").

 - Al pulsar sobre una imagen, ésta se "colocará" en "div.blogMarqueePhoto img#cp".
 - Al pulsar sobre las flechas, podremos navegar por las imágenes (mientras se mantenga el ratón pulsado)

 - Al pulsar sobre "div.blogMarqueePhoto img#cp", la imagen se abrirá a tamaño real en una ventana nueva.

Aquí vemos dos cosas a destacar:

a) Hay un solapamiento de eventos javascript.
b) Tenemos que controlar cuándo el ratón está pulsado sobre "div#bMSL" y "div#bMSR".


Teniendo estas dos cosas en cuenta, vamos a pasar a ver la estructura HTML de nuestra galería:


<div class="blogMarquee">
<div class="blogMarqueePhoto">
                <img src="" alt="" width="400" height="300" id="cp" onclick="external(this);">
         </div>
<marquee id="bM" onmouseout="setAmount(this,5);" onmouseover="setAmount(this,0);" srcollamount="5">
<!-- imágenes aquí, en formato: width=320 height=240 -->
</marquee>
<div class="blogMarqueeScroll" onmouseover="setAmount(ge('bM'),0);">
<div id="bMSL" class="binv" onmousedown="action([ge('bM'),10,false],true);" onmouseup="action([ge('bM'),0,false],true);"> < </div>
<div id="bMSR" class="binv" onmousedown="action([ge('bM'),10,true],true);" onmouseup="action([ge('bM'),0,true],true);"> > </div>
</div>
<script type="text/javascript">addId(ge('bM'));</script>
</div>

(No me gusta que desfase el ancho del blog... pero así se ve mejor)

Como vemos, al final hay una llamada JavaScript. Ésta sirve para dar "id" a cada imagen dentro de marquee (ya veremos cómo, en un momento).

Antes de entrar en JS, vamos a estudiar un poco el HTML.

Como vemos, tenemos la estructura comentada, así que no pararemos ahí, sino que veremos el el elemento "marquee#bm".

Vemos que tiene "scrollamount=5". Esto indica la velocidad (5, en este caso) a la que se mueven los elementos. La dirección la veremos más adelante.

Ahora, vamos a por el JS (explicado con comentarios):


/**
 * variable global para el solapamiento
 */
var b_max=2;

/**
 * función action. 
 * Actúa como manejador de solapamiento de eventos entre "marquee#bm img:click" (a) y ("div#bMSL" | "div#bMSR") (b).
 * (a) lanza cphoto
 * (b) lanza move
 * Recibe dos parámetros:
 * @param v: array de parámetros de subllamada
 * @param f: valor de flag 
 */
function action(v,f){
b_max--;

if(f&&b_max>0){
move(v[0],v[1],v[2])
}else{
if(!f){
cphoto(v[0])
}
}

if(b_max==0||f){
b_max=2
}
}

/**
 * función ge.
 * Sinónimo de función "document.getElementById".
 * Recibe un parámetro y retorna un elemento:
 * @param e: id del elemento a retornar
 * @return: elemento cuyo id corresponde a "e"
 */
function ge(e){
return document.getElementById(e)
}

/**
 * función setAmount.
 * Ajusta la velocidad (scrollAmount) del elemento "e" a la velocidad "a".
 * Si la velocidad es 0, se muestran las flechas; en caso contrario se ocultan.
 * Recibe dos parámetros:
 * @param e: elemento a ajustar
 * @param a: velocidad
 */
function setAmount(e,a){
e.direction='left';
e.scrollAmount=a;

if(a==0){
ge('bMSL').className='bMSL';
ge('bMSR').className='bMSR'
}else{
ge('bMSL').className='binv';
ge('bMSR').className='binv'
}
}

/**
 * función addId.
 * Itera sobre el elemento con id "e", y sobre sus hijos, asigna id's de forma secuencial.
 * Del mismo modo, asigna un handler "click" a cada elemento.
 * Recibe un parámetro:
 * @param e: id del elemento a iterar
 */
function addId(e){
am=0;

for(i=0;i<e.childNodes.length;i++){
try{
e.childNodes[i].setAttribute('id','el'+am);
e.childNodes[i].setAttribute('onclick','action([this],false)');
am++
}catch(err){
}
}
}

/**
 * función move.
 * Mueve el elemento "e", en la dirección indicada por "t" a una velocidad "a".
 * Recibe tres parámetros:
 * @param e: elemento a mover
 * @param a: velocidad a fijar
 * @param t: dirección (true para derecha, false para izquierda)
 */
function move(e,a,t){
if(t){
e.direction='right'
}else{
e.direction='left'
}

e.scrollAmount=a
}

/**
 * función cphoto.
 * Muestra el elemento "e" sobre el elemento "#cp"
 * Recibe un parámetro:
 * @param e: elemento a mostrar sobre "#cp"
 */
function cphoto(e){
ge('cp').setAttribute('src',e.getAttribute('src'))
}

/**
 * función external.
 * Abre, en una ventana nueva, el elemento "e".
 * Recibe un parámetro:
 * @param e: elemento a abrir
 */
function external(e){
if(e.getAttribute('src')!=null){
window.open(e.getAttribute('src'))
}
}


Ahora, trataremos los dos asuntos:

a) Solapamiento: usamos este sistema para evitarlo.
b) Se generan dos eventos: onmousedown (cuando la tecla está pulsada) y onmouseup (cuando se suelta la tecla). En el primero, indicamos que se mueva hacia la dirección indicada; en el segundo, indicamos que pare.

Por último, falta indicar el estilo de nuestra nueva función:


img{
border:0;
}

.blogMarqueePhoto{
height:300px;
width:400px;
margin-left:auto;
margin-right:auto;
padding:10px;
}

.blogMarqueePhoto img{
width:400px;
height:300px;
border:1px solid #CCC;
 padding:0px
}

.blogMarqueePhoto img:hover{
cursor:pointer;
border-color:#FFF;
}

#bM{
height:245px;
}

.blogMarqueeScroll div{
top:-245px;
width:100px;
height:240px;
position:relative;
font-familt:arial;
font-size:180px;
color:#FFF;
line-height:240px;
opacity:.5;
-moz-opacity:.5;
filter:alpha(opacity=50);
background:#000;
}

.bMSL{
float:left;
}

.bMSR{
float:right;
}

.binv{
display:none;
}

#bM img{
 padding:0px;
}

#bM img:hover,.bMSR:hover,.bMSL:hover{
cursor:pointer;
}

Y ya solo falta rellenar con imágenes y colocarlo en una entrada.

Aquí podéis ver un ejemplo en funcionamiento. Un consejo: usad el ingenio para "importar" fotos desde facebook ;-)

"Juguete":


























Aquí está. Es una lámpara-tecla que compré en la feria del cómic de Barcelona. Mide unos 15cm de largo y se queda en mi despacho.

Ahora ya puedo decir que tengo la luz bajo control ;-)


Cambios:

Hace tiempo que voy detrás de graduarme en la universidad, pero lo que quería hacer estaba fuera de presupuesto (aunque tengo que admitir que de hacer algo relacionado 100% con la informática me gustaría hacerlo); un Bachelor en un centro adscrito a la universidad de Gales. Son tres años de carrera repleta de asignaturas con muy buena pinta...

Pero se va de presupuesto, así que vivía resignado.

Hasta que repasando los apuntes de mates me picó el gusanillo otra vez... así que ahí lo dejo:

¡Me voy a graduar en matemáticas!

Ya me he visto la carrera que voy a hacer y es buena, barata y a distancia. ¡Ale! así, entre curso y curso, podré hacer cursillos de informática (nunca hay que dejar de estudiar)... con este paso estoy más cerca de ser doctor... :-)

Desde luego no es un cambio que haya estado "esperando", más bien vino así de golpe... pero ya está bien.

Remote Tools: Presentación (V)

Buenas!

En esta entrada terminamos la presentación de la herramienta "Remote Tools".

Después de esta, habrá un breve interludio en el que os pondré al día de todo (hay varias cosas que tratar que no he expuesto por no alterar el ritmo de las publicaciones), y seguidamente a éste volveremos a las matemáticas (tema II).

Y bien, ahora toca hablar de la herramienta nmap.

Quizás alguno de mis lectores (aunque no comentéis se que estáis ahí, y me alegro de que me leáis - y sobretodo si os ayuda en algo :-) ) ya conoce de la existencia de esta herramienta; no obstante, vamos a hacer un repaso rápido.

Nmap es una herramienta de diagnóstico de redes. Nos permite ejecutar varias "operaciones" sobre un trozo de la red.

Vamos a ver un poco su interfaz:


Se distinguen varias zonas claras:

  • Tipo de perfil: seleccionamos la acción a realizar. Hay una cantidad considerable de perfiles. En este caso tenemos seleccionado simplemente un "Ping Scan".
  • Rango de IP: rango de IP a analizar con el perfil seleccionado. Permite IP única (por ejemplo 192.168.1.1) o un rango (por ejemplo 192.168.1-2.1-255).
  • Comando a ejecutar: es la petición que se lanzará (lo veremos más adelante)
  • Lista de Host: Host/s que han respondido a la petición.
  • Output: salida de texto que lanza el programa.
  • Filtro: podemos filtrar los hosts usando esta barra de filtro.
En este caso, he realizado un ping a toda mi red local. Esto podría servir (por ejemplo) para ver si hay algún intruso, ya que al finalizar el trabajo, tendremos una lista con todos los dispositivos conectados a la red (en este caso: router, pc y mi teléfono).

Más adelante (cuando haga la sección) podremos ver como podríamos "burlar" esto, pero valga esto como ejemplo.

Aparte de esto, tiene otras herramientas, como un panel donde se muestran los puertos abiertos (si hacemos un escaneo más potente) del host seleccionado. En concreto, tiene las siguientes opciones (pestañas):
  • Nmap output: muesta el output.
  • Ports/Hosts: muesta los puertos escaneados del host seleccionado.
  • Topology: muestra la topología de los hosts (un tracert).
  • Host details: muestra detalles del host: SO, nº de puertos abiertos...
  • Scans: muestra una lista de los scans realizados.
Y bien, como podéis intuir esta herramienta es muy potente; pero no todo acaba ahí. Nmap tiene una parte "oculta"... usa un "bridge" (API, si queréis) basado en cmd.

Es decir, podemos ir a nuestro cmd, a la carpeta donde tengamos nmap (o desde donde sea si lo tenemos en PATH) y ejecutar consultas ahí mismo, usando el comando adecuado.

¿Y qué comando usamos? precisamente el que sale en nmap cuando ejecutamos los perfiles.

Entonces, podríamos hacer, por ejemplo: 

nmap -sn 192.168.1-2.1-255 > test.dat

Y tendríamos un archivo "test.dat" con la información de output de nmap.

Entonces, el objetivo de Remote Tools es hacer este tipo de llamadas para obtener información de las diferentes LAN.

Usando esto con cabeza, podemos agilizar las auditorías un poco...

Y bien, con esto acabamos el primer apartado de nuestra futura aplicación... ¡espero que os guste!

¡Hasta la próxima!

Remote Tools: Presentación (IV)

Buenas!

Llegamos casi al final de la presentación del proyecto Remote Tools... los cambios siguen (como siempre) demorados; pero otro tipo de cambios han sucedido...

En parte me alegro por los cambios que ya han tenido lugar; no obstante, me gustaría que sucediera por fin el cambio que tanto ansío...

En fin... sigamos con lo que vamos.

En esta entrada toca hablar de la fuerza bruta (aplicada a la informática).

¿Habéis oído eso de "más vale maña que fuerza"? Pues está relacionado...

Siguiendo con el ejemplo de la entrada anterior, vamos a introducir el concepto de fuerza bruta, y, sobretodo, cómo aplicarla de manera correcta (es decir, aplicar fuerza con maña).

Si recordamos, hablábamos de una función para calcular claves por defecto, tal que:

f(x, y, z) = subs(enc(z + 2y + ent(x/z)), 20)

Ahora bien: obtenidos todos los datos, obteníamos una única solución, por lo que no hacía falta nada más.

Pero claro, si yo fuera un fabricante de routers, haría la cosa algo más complicada, por ejemplo:

f(x, y, z) = con(subs(enc(z + 2y + ent(x/z)), 15), k)

donde "x", "y", y "z" serían los mismos valores; "subs", "enc", y "ent" las mismas funciones. Además:

 - "con": función de concatenación de todos los ítems de la lista
 - "k": variable que (valga la redundancia) es variable para cada router, y no hay manera de saber

Entonces... ¿Cómo calculamos ahora la clave del router?

La respuesta está en la fuerza bruta.

Podríamos empezar a pensar, y podemos intuir que, si antes tenía 20 dígitos de longitud, la clave seguirá teniendo los mismos dígitos.

Si eso es cierto, sabemos que "k" es un valor de 5 dígitos de longitud.

Ahí tenemos algo acotado ya: sabemos que:

k = abcde

de manera que "a", "b", "c", "d", y "e" pueden tomar cualquier valor alfanumérico posible.

Como su nombre indica, la "fuerza bruta" consiste en acceder por la fuerza, probando todas las combinaciones posibles de manera automática hasta dar con la correcta.

Y para aplicar la fuerza tenemos dos maneras:

 - Manera óptima
 - Manera bruta

Primero, ya que es más corto, explicaremos la manera "bruta":

Consiste en probar absolutamente todo. En este caso, sabiendo que tenemos 20 caracteres, haríamos cadenas de 20 caracteres y las iríamos probando "a saco". Haciendo unos cálculos obtenemos:

 * Números del "0" al "9" => 10 caracteres
 * Letras de la "a" a la "z" (la "ñ" no cuenta en este caso) => 26 caracteres
 * Letras de la "A" a la "Z" => 26 caracteres

Por tanto, tenemos 62 posibilidades en cada posición, por 20 posiciones:

n = 62^20 = 704.423.425.546.998.022.968.330.264.616.370.176 posibilidades

Bien, a una velocidad de 5.000 posibilidades probadas por segundo, tardaríamos 1630609781358791719834097834.7601161481481481481483 días (4467424058517237588586569.4103016880771182141045159 años aprox.) en completar nuestra búsqueda.

Como se ve, ciertamente imposible...

La manera óptima, sin embargo, es más optimista, ya que haríamos lo siguiente:

 * Sabemos que "k" tendrá 5 caracteres, por lo tanto:

n = 62^5 = 916.132.832 posibilidades

Wow, hasta podemos ver que son menos de un billón (la cifra anterior cuesta de ver, incluso). Con el cómputo anterior (5.000 posibilidades/segundo) tendríamos:

t = n/(60*60*24*5000);
t = 2.1206778518518519h

Bueno, un par de horas; podríamos ir a tomar algo dejando el ataque en marcha, y al volver tendríamos nuestra clave :-)

En definitiva, aplicar la fuerza bruta es cuestión de maña...

No obstante, hay veces que simplemente no se puede. Estas situaciones son, entre otras:

 - Passwords "personales" (definidos por cada usuario)
 - Claves propias
 - Todo aquello que no sea computado

En estos casos, podemos hacer varias pruebas, como jugar con longitudes, juegos de caracteres, o usar la ingeniería social (o técnicas maliciosas como keyloggers, sniffers, phishing...).

En nuestra aplicación, empezaremos con un concepto "global" de fuerza bruta: es decir, generaremos diccionarios (conjuntos de posibilidades) acorde a los parámetros que de el usuario, y los devolveremos. Será cuestión del usuario usarlos.

Como en cada una de estas entradas, dejo un tema pendiente: obtención de datos mediante diversas técnicas (estas entradas irán con un banner más grande que un bocadillo de surimi con wasabi).

Si no ha quedado claro en el párrafo anterior, cuando abordemos (más adelante) este tema, será como contramedida; es decir, de manera informativa y para estar informados y al loro de las maneras en las que nos podrían engañar (en ningún momento recomiendo usar técnicas maliciosas para robar información, ya que puede ser delito).

La próxima entrada abordará el tema de un programa que nos puede ser útil: nmap.

Como siempre digo,

¡Hasta la próxima!