Introducción
Vulnsever es un servidor TCP multiproceso que escucha conexiones de clientes en el puerto 9999 (por defecto) y permite al usuario ejecutar comandos diferentes. Este servidor tiene vulnerabilidades de Buffer Overflow. Vamos a tratar de explotarlas.
Procedimiento
Fuzzing
Vamos a probar el desbordamiento de buffer Vamos a enviar trazas de bytes de datos al programa supuestamente vulnerable en interacciones crecientes para desbordar el buffer y sobreescribir el EIP.
Vemos una lista de todos los comandos que están disponibles. Vamos a tratar de fuzzear algunos de estos comandos para ver donde falla.
Esta es la forma de hacer fuzzing manual, pero es muy lento. Vamos a crear un script que automatice esta tarea.
Debemos esperar hasta que el programa colapse y veamos el estado “Paused” en Immunity Debugger. El servidor se bloquea después de enviar 5900 bytes. Ya tenemos una idea general de como bloquear el programa.
El siguiente paso será averiguar donde está el EIP para intentar controlarlo.
Encontrar el offset
Ahora que sabemos como sobreescribir el EIP y que esta sobreescritura ocurre entre 1 y 5900 bytes, ya podemos continuar con la explotación de la vulnerabilidad.
Vamos a utilizar la herramienta Pattern_Create para generar una string en función del número de bytes especificado. Luego enviaremos esa cadena al servidor vulnerable para intentar encontrar donde se sobreescribe el EIP. Para ello, utilizaremos la Pattern_Offset. Estas herramientas se encuentran por defecto en /usr/share/metasploit-framework/tools/exploit.
Ahora utilizaremos el siguiente script escrito en Python para enviar la cadena generada con anterioridad a la aplicación vulnerable.
Enviamos la string generada a la máquina vulnerable al mismo tiempo tenemos levantado Immunity Debbugger en la máquina Windows vulnerable.
Tenemos un valor para el registro EIP (386F4337). El siguiente paso será averiguar la ubicación donde comienza el EIP.
Ahora sabemos la ubicación exacta donde comienza el EIP y ahora pasaremos a intentar controlar el EIP.
Sobreescribir el EIP
Ahora que sabemos que el EIP comienza en 2003 bytes, vamos a utilizar el siguiente código para confirmarlo.
Primero vamos a enviar 2003 ‘A’ y luego enviaremos 4 ‘B’, ya que el EIP tiene un tamaño de 4 bytes.
El script que utilizaremos es el siguiente:
Volvemos a ejecutar la aplicación vulnserver.exe en Immunity Debugger en la máquina Windows de prueba y el script Python creado en nuestra máquina de ataque.
Ahora el valor del EIP es “42424242”. El siguiente paso es la búsqueda de ‘badchars’ de la aplicación Vulnserver. Por defecto, el byte nulo (x00) siempre es un carácter incorrecto.
Búsqueda de badchars
Algunos caracteres de byte pueden causar problemas en el desarrollo de exploits. Debemos pasar cada byte a través del programa Vulnserver para ver si hay algún carácter que cause problemas. Por defecto, el byte nulo (x00) siempre se considera un carácter malo, ya que truncará el shellcode cuando se ejecute. Para encontrar caracteres malos en Vulnserver, podemos agregar una variable adicional de “badchars” a nuestro código que contenga una lista de todos los caracteres hexadecimales. Para ello ejecutamos el siguiente código:
Haga clic derecho en el registro ESP y seleccione “Follow in dump”
Si hubiese algún badchar en el código, notaríamos que el volcado hexadecimal anterior no mantendría el orden correlativo y se introducirían caracteres fuera de lugar. Podemos notar que no hay ningún badchar.
Encontrar el módulo adecuado
Para encontrar el módulo adecuado, debemos buscar una parte de Vulnserver que no tenga protección de memoria. Para hacerlo, utilizaremos los módulos de Mona.
‘essfunc.dll’ se ejecuta como parte de Vulnserver y no tiene protecciones de memoria.
Ahora procederemos a encontrar el código de operación equivalente a JMP ESP. Estamos utilizando JMP ESP porque nuestro EIP apuntará a la dirección de JMP ESP, que luego saltará a nuestro shellcode malicioso que inyectaremos más adelante.
JMP ESP
Vamos a verificar si hay instrucciones JMP ESP disponibles asociadas con essfunc.dll, usando el comando !mona jmp -r esp -m “essfunc.dll” de la siguiente manera.
Sobreescribir el EIP
Vamos a utilizar el valor de la primera dirección de retorno, 625011af, para tratar de sobrescribir el EIP con la dirección encontrada anteriormente. La utilizaremos en orden inverso, ya que la arquitectura x86 es little-endian.
Para ello utilizaremos el siguiente script:
Pero antes, debemos hacer lo siguiente:
Para verificar nuestra dirección de retorno, es necesario encontrarla en Immunity Debugger. Si acabamos de conectar Vulnserver, podemos hacerlo haciendo clic en la flecha del extremo derecho en el panel superior de Inmunidad.
Después, es necesario buscar en el mensaje “Ingrese la expresión a seguir” la cadena de caracteres “625011AF” (o la dirección de retorno que se haya encontrado) sin incluir las comillas. Una vez que se ha localizado esta dirección de retorno, que se encuentra en la ubicación JMP ESP con la dirección FFE4, se debe presionar la tecla F2 para establecer un punto de interrupción, lo que se indicará con el cambio del color de la dirección a un tono azul claro.
Una vez que el código ha sido ejecutado, es importante verificar si se ha activado el punto de interrupción establecido anteriormente en Immunity Debugger. Si se ha detectado la activación del punto de interrupción, esto indica que se ha alcanzado el objetivo buscado y que se está preparado para llevar a cabo la tarea deseada.
Así es. Una vez que se ha establecido el punto de interrupción, se ha logrado identificar la dirección de retorno correcta y se ha determinado que se puede sobrescribir el registro EIP con la dirección de retorno de JMP ESP. A partir de ahí, el siguiente paso es apuntar la dirección de retorno de JMP ESP a nuestro shellcode para ejecutarlo. Esto se logra al construir el shellcode correctamente y asegurarse de que se ajuste a las limitaciones de espacio y formato en el que se está trabajando.
Generar la Shell
Primero generamos la carga útil:
La dirección de LHOST será la de nuestra máquina de ataque, 192.168.220.134.
Posteriormente, añadimos esta carga al siguiente script en Python.
Según TCM, se debe crear una variable llamada ‘exploit’ y colocar el shellcode malicioso dentro de ella. También es necesario agregar ’32 * \x90′ a la variable de shellcode (32 bytes de \x90). Esto es una práctica estándar. El byte 0x90 también se conoce como NOP (operación nula) y en realidad no hace nada. Sin embargo, al desarrollar exploits, podemos usarlo como relleno. En algunos casos, nuestro código de exploit puede interferir con la dirección de retorno y no funcionar correctamente. Para evitar esta interferencia, podemos agregar un poco de relleno entre los dos elementos.
Y ya tendriamos preparado nuestro exploit para explotar la vulnerabilidad de BOF presente en la aplicación VulnServer.
No responses yet