Hace poco, y terminando ya un día de trabajo, me di cuenta de que la batería de mi
smartphone Android se había drenado en cosa de 8-9 horas, del más absoluto de los idle's, hasta llegar al 0% y morir tras un agónico final sin cargador. Se trata de un Samsung Galaxy S III, que por aquella tenía embebida una versión del popular sistema operativo para
smartphones y
tablets de google número 4.0.4, también conocida como Ice Cream Sandwich. Tras este agónico final en tan poco tiempo me decidí a echar un ojo al
tráfico que genera el terminal, a ver si se veía algo extraño ya que se ha visto por el market apliaciones fraudulentas que poco más que hacían que dar dinero a sus creadores generando tráfico basura desde nuestro Android a diferentes servicios que pagan por "click".
En este punto,
@aramosf me comentó sobre un proxy transparente presentado en la Black Hat de 2010 utilizado precisamente para estos menesteres. Así que me puse a ello.
Mi infraestructura iba a constar de:
- Un ordenador de sobremesa
- Mi maltrecho móvil
- Un router wifi
Ni más ni menos. Si además contamos con un portátil y un par de interfaces wi-fi podemos crear un AP falso para pasearlo por distintas ubicaciones públicas ;) Pero eso será objecto de otra entrada, ya que de momento mi portátil se encuentra fuera de combate.
Yo me decidí a realizar el MITM mediante una VPN, bastante fácil de configurar en Linux y ensucia menos la red que un arpspoof. Si elegimos el segundo método después tendremos que crearnos nuestras propias reglas en iptables, para enrutar el tráfico y que pase por mallory. Pero ese es otro tema, puesto que mallory junto con una VPN nos facilita enormemente la labor en este sentido.
Existe una máquina virtual con
mallory pre-instalada, para descargar de su web
oficial, yo me decidí a instalarlo directamente en el backtrack que tengo configurado sobre una máquina virtual.
La interfaz de red de mi máquina virtual la tengo configurada como "adaptador puente" o "bridge interface". De esta manera el DHCP del router es capaz de asignarle una dirección tal y como si fuera una interfaz física más dentro de la red.
Vamos a descargar y ejecutar la aplicación pptpd que será la encargada de crear nuestra VPN, y endpoint de nuestro terminal móvil.
root@bt:~/Desktop/mallory/mallory/scripts# apt-get install pptpd
Ahora vamos a configurarlo. Para ello editamos el archivo /etc/pptpd.conf y localizamos las líneas donde se definen la ip local del servidor VPN y las ips remotas que van a ser asignadas a nuestros clientes VPN.
root@bt:~/Desktop/mallory/mallory/scripts# vi /etc/pptpd.conf
###############################################################################
# $Id: pptpd.conf 4255 2004-10-03 18:44:00Z rene $
#
# Sample Poptop configuration file /etc/pptpd.conf
#
# Changes are effective when pptpd is restarted.
###############################################################################
localip 192.168.1.22
remoteip 192.168.1.230-240
Si estas dos líneas están comentadas (#) las descomentamos y en localip definimos la ip local del servidor VPN y en remoteip el rango de direcciones ips que queremos que se asignen a los clientes que se van a conectar.
El siguiente paso es configurar un par usuario/contraseña para conectarnos. Debemos editar el archivo
chap-secrets que se encuentra en /etc/ppp/
root@bt:~/Desktop/mallory/mallory/scripts# vi /etc/ppp/chap-secrets
# Secrets for authentication using CHAP
# client server secret IP addresses
user pptpd password *
Este archivo contiene las parejas usuario/contraseña válidas para acceder a nuestra red privada virtual. El primer campo será el usuario, el segundo la aplicación que se alimentará de estas credenciales, el tercero la contraseña y el último el rango de direcciones ips autorizadas a acceder a ese recurso.
Guardamos y reiniciamos el servicio pptpd:
root@bt:~/Desktop/mallory/mallory/scripts# /etc/init.d/pptpd restart
Y ya deberíamos ser capaces de conectarnos a través de nuestra recién configurada VPN. En android el proceso es muy sencillo. Aplicaciones -> Ajustes -> En conexiones inalámbrica buscamos Más ajustes -> VPN
Añadimos una red VPN con el usuario y contraseña que acabamos de definir en chap-secrets y con la dirección ip donde se encuentra la máquina servidor. Si todo ha ido bien deberíamos estar conectados ya.
Ahora procederemos a la instalación de mallory.
sudo apt-get install mercurial;
sudo apt-get install python-pyasn1;
sudo apt-get install python-netfilter;
sudo apt-get install libnetfilter-conntrack-dev;
sudo apt-get install python2.6-dev;
sudo apt-get install python-setuptools;
sudo easy_install pynetfilter_conntrack;
sudo apt-get install netfilter-extensions-source;
sudo apt-get install libnetfilter-conntrack3-dbg;
sudo apt-get install python-paramiko;
sudo apt-get install python-imaging;
#If you are installing Mallory on a 32 bit machine
wget http://ubuntu.cs.utah.edu/ubuntu/pool/universe/libn/libnetfilter-conntrack/libnetfilter-conntrack1_0.0.99-1_i386.deb
sudo dpkg -i libnetfilter-conntrack1_0.0.99-1_i386.deb
-
#if you are installing Mallory on a 64 bit machine
wget http://ubuntu.cs.utah.edu/ubuntu/pool/universe/libn/libnetfilter-conntrack/libnetfilter-conntrack1_0.0.99-1_amd64.deb
sudo dpkg -i libnetfilter-conntrack1_0.0.99-1_amd64.deb
-
Instalamos todas las librerías y dependencias que son necesarias y dependiendo de si nos encontramos en un sistema operativo de 32 ó 64 bits instalaremos el primer o el segundo .deb
Dentro de la ruta de instalación de mallory podemos encontrar tres directorios principales:
- mallory/db Que contienen las bases de datos sqlite en las que se insertan todos los streams que pasan por mallory
- mallory/scripts Scripts para la configuración de iptables para realizar el MITM, además de uno para bloquear el spam que entraba hace años por netbios (:?) y por el servicio de windows messenger service. Nosotros no vamos a necesitar estos scripts puesto que vamos a lanzar la interfaz gráfica de mallory, que lo hará por nosotros. Pero para que se sepa deberíamos modificar config_router.sh y config_mallory.sh con las interfaces de entrada y salida.
- mallory/src Donde se encuentra el core de programa. Los dos ejecutables que necesitamos (mallory.py y launchgui.py) además de un directorio con el certificado y demás ejecutables.
Abrimos un par de terminales y en una ejecutamos el proxy en sí.
root@bt:~/Desktop/mallory/mallory/src# python mallory.py
/root/Desktop/mallory/mallory/src/config_proto.py:3: DeprecationWarning: the sets module is deprecated
-
-
[*] [2012-12-09 19:50:39,404] INFO:Logging setup complete
[*] [2012-12-09 19:50:39,406] INFO:[*] SSHProtocol: Initializing
[*] [2012-12-09 19:50:39,409] INFO:HTTP protocol handler initialized
[*] [2012-12-09 19:50:39,409] DEBUG:SSLProtocol: Initializing
[*] [2012-12-09 19:50:39,410] DEBUG:SSLProtocol: Initializing
[*] [2012-12-09 19:50:39,411] INFO:ConfigRules.init: LOADING RULES.
[*] [2012-12-09 19:50:39,413] INFO:ConfigRules.load_config: Rule Action String is:Debug
[*] [2012-12-09 19:50:39,417] DEBUG:NetfilterTool: Instantiating object.
[*] [2012-12-09 19:50:39,418] INFO:RPCServer: add_remote_obj - adding remote object
-
[*] [2012-12-09 19:50:39,445] DEBUG:NetfilterTool: Instantiating object.
[*] [2012-12-09 19:50:39,446] DEBUG:UDPProtocol[m]: Waiting for data
Ahora deberemos arrancar la interfaz gráfica que se conecta a través de un servidor xmlrpc a mallory.
root@bt:~/Desktop/mallory/mallory/src# python launchgui.py
Y la interfaz gráfica arrancará. Si os da un warning acerca de una librería no instalada instaladla si vais a utilizar la interfaz del programa sobre la base de datos. Luego veremos cómo.
Ahora lo primero es realizar el MITM. Lo primero que se nos abre es la pestaña de interfaces en la que vamos a escoger la interfaz por la que "entra" el tráfico que queremos analizar y la interfaz por la que "sale" hacia internet. Y es tan sencillo cómo seleccionarlas mediante botones:
En mi caso he seleccionado la interfaz ppp0 (la del único cliente que tengo conectado a la VPN, recordemos que con cada cliente conectado el demonio crea un nuevo adaptador virtual punto a punto) como interfaz de "entrada" o donde mallory lo etiqueta como Perform MITM y eth0 como interfaz de "salida", o etiquetado tal cual está en mallory Outbound interface. Una vez hecho esto sólo tenemos que hacer click en Apply Configuration y la aplicación solita se encarga de agregar las reglas a iptables que son necesarias como podremos ver si ponemos en primer plano la terminal de la que cuelga la interfaz gráfica de mallory.
Lo que hacen estas reglas básicamente es redirigir todo el tráfico tanto tcp como udp que llega por ppp0 hacia el puerto de escucha de mallory, el 20755. Además añade un MASQUERADE en la interfaz de salida y activa el ip_forwarding.
Ahora nos vamos a la pestaña protocols, dónde podemos ver los protocolos y puertos que queremos interceptar.
Tan sólo tenemos que quitar los comentarios (;) del principio de línea de la definición de protocolos y puertos y clickear en Apply para activar la intercepción de estos protocolos y puertos. Por el momento tenemos disponibles tres, que son ssh, ssl y http.
Podemos añadir fácilmente tráfico en otro puerto, por ejemplo:
miproto:sslproto.SSLProtocol:5222
La pestaña rules es un potente modificador de tráfico, que nos permitirá automatizar el proceso de modificación de tráfico mediante patrones y reglas, aunque también podemos hacer modificaciones manualmente en "tiempo real".
La pestaña rules contiene la salsa de la aplicación, dónde en tiempo real, se muestra todo el tráfico que la aplicación está capturando, en base a los protocolos que hemos definido en la pestaña protocols. Debemos activar el botón de Intercept para que la aplicación muestre el tráfico y lo guarde en la base de datos y Auto-send si de momento sólo queremos mirar y no modificar nada. Casi inmediatamente y si tenemos nuestro terminal conectado a la vpn deberíamos empezar a ver trazas yendo y viniendo de aquí para allá, puesto que nuestros smartphones sabéis que están constantemente sincronizando y enviando otro tipo de datos a diferentes servicios. Por ejemplo, yo me di cuenta de que al abrir Chrome en mi android está casi continuamente mandando información contra un servidor de google para sincronizar las pestañas abiertas en los diferentes dispositivos que tenemos enlazados con nuestra cuenta de google.
¿Pero y qué ocurre si intentamos acceder a una web mediante https? Esto:
Chrome además de avisarnos de que el certificado no es válido, ni siquiera nos permite proseguir aceptando los riesgos. ¿Cómo se comportan este tipo de proxies cuando accedemos a un recurso mediante SSL? Tienen una ca interna que genera certificados autofirmados para cada web que visitemos. Además de todo esto, las aplicaciones que utilizan SSL para comunicarse con sus servidores ni siquiera funcionarán. Así que para solucionar este entuerto instalaremos el .cer en el terminal que nos permitirá salvar esta situación.
En algún sitio había leído que era un lío instalar un certificado en android, así que busqué y encontré un método en el que necesitábamos root en el teléfono y una shell en éste mediante el SDK de Android. Android posee un contenedor de certificados en /system/etc/security/cacerts/ donde se almacenan todos los instalados en el télefono. El nombre de los certificados es un hash del subject del certificado, seguido de un .0 ó .1, .2... si existen colisiones. Así que el directorio nos queda tal que así:
shell@android:/system/etc/security/cacerts # ls -l
-
-rw-r--r-- root root 4767 2012-09-28 14:15 00673b5b.0
-
-rw-r--r-- root root 5106 2012-09-28 14:15 ff783690.0
Después tan sólo hacíamos el mencionado hash con openssl x509 -noout hash -in .../mallory/src/ca/cer.key, renombrábamos el certificado a ese hash (más un .0) y lo metíamos mediante un adb push al directorio contenedor de certificados. Pero a mí particularmente no me funcionó. Por lo que puse en marcha la solución sencilla. Montar un apache, meter ahí el certificado de mallory y acceder desde el móvil para descargarlo. Dicho y hecho.
Pinchando en él se descarga a la SD, por lo que el siguiente paso en el móvil es ir a Ajustes -> Seguridad -> Instalar desde almac dispositivo -> seleccionar el certificado que acabamos de descargar. Si ahora vamos a Credenciales de confianza -> pestaña Usuario, debería aparecer el certificado que acbamos de instalar.
Ahora intentamos acceder a una web con https y...
Ya confía en nosotros :) Ahora podremos ver el tráfico en claro desde mallory:
Además de que otras aplicaciones que transmiten sobre SSL también funcionarán :)
Mallory además tiene una interfaz contra la base de datos que podemos utilizar para consultarla sobre los streams almacenados. En la pestaña advanced podemos pulsar sobre create flow query y nos generará una consulta con los campos más importantes para poder ver un flujo de tráfico.
Además podemos abrirla directamente con sqlite3 y hacer consultas desde la línea de comandos. Para ver el schema de la base de datos:
root@bt:~/Desktop/mallory/mallory/db# sqlite3 trafficdb
SQLite version 3.7.11 2012-03-20 11:35:50
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> .schema
CREATE TABLE connections(
connCount INTEGER,
serverIp TEXT,
serverPort INTEGER,
clientIp TEXT,
clientPort INTEGER
);
[...]
sqlite>
Y con .help podemos ver todos los comandos disponibles en sqlite3. Por ejemplo, .tables nos mostrará el nombre de todas las tablas de esa base de datos.
Con todo esto en marcha, no sería muy difícil crear un punto de acceso falso, conseguir clientes que se conectarían pensando que es un AP legítimo, colocarles una especie de portal cautivo dónde se les pidiera la instalación del certificado y a continuación dejarles navegar con normalidad.
Para otra entrada queda cómo crear un punto de acceso falso con
hostapd.
