WWW2Exec - __malloc_hook & __free_hook

Reading time: 4 minutes

Malloc Hook

Como se puede ver en sitio oficial de GNU, la variable __malloc_hook es un puntero que apunta a la dirección de una función que será llamada cada vez que se llame a malloc(), almacenada en la sección de datos de la biblioteca libc. Por lo tanto, si esta dirección se sobrescribe con un One Gadget, por ejemplo, y se llama a malloc, se llamará al One Gadget.

Para llamar a malloc, es posible esperar a que el programa lo llame o llamando a printf("%10000$c"), lo que asigna demasiados bytes, haciendo que libc llame a malloc para asignarlos en el heap.

Más información sobre One Gadget en:

One Gadget

Free Hook

Esto fue abusado en uno de los ejemplos de la página que abusaba de un ataque de fast bin después de haber abusado de un ataque de unsorted bin:

Unsorted Bin Attack

Es posible encontrar la dirección de __free_hook si el binario tiene símbolos con el siguiente comando:

gef➤  p &__free_hook

En la publicación puedes encontrar una guía paso a paso sobre cómo localizar la dirección del hook de free sin símbolos. Como resumen, en la función free:

gef➤  x/20i free
0xf75dedc0 : push   ebx
0xf75dedc1 : call   0xf768f625
0xf75dedc6 : add    ebx,0x14323a
0xf75dedcc :  sub    esp,0x8
0xf75dedcf :  mov    eax,DWORD PTR [ebx-0x98]
0xf75dedd5 :  mov    ecx,DWORD PTR [esp+0x10]
0xf75dedd9 :  mov    eax,DWORD PTR [eax]--- BREAK HERE
0xf75deddb :  test   eax,eax ;<
0xf75deddd :  jne    0xf75dee50 

En el mencionado break en el código anterior, en $eax se localizará la dirección del hook de free.

Ahora se realiza un ataque de fast bin:

• En primer lugar, se descubre que es posible trabajar con chunks de tamaño 200 en la ubicación de __free_hook:

• gef➤  p &__free_hook
  

$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook> gef➤ x/60gx 0x7ff1e9e607a8 - 0x59 0x7ff1e9e6074f: 0x0000000000000000 0x0000000000000200 0x7ff1e9e6075f: 0x0000000000000000 0x0000000000000000 0x7ff1e9e6076f <list_all_lock+15>: 0x0000000000000000 0x0000000000000000 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000 0x0000000000000000

• Si logramos obtener un chunk rápido de tamaño 0x200 en esta ubicación, será posible sobrescribir un puntero de función que se ejecutará.
• Para esto, se crea un nuevo chunk de tamaño 0xfc y se llama a la función combinada con ese puntero dos veces, de esta manera obtenemos un puntero a un chunk liberado de tamaño 0xfc*2 = 0x1f8 en el fast bin.
• Luego, se llama a la función de edición en este chunk para modificar la dirección de fd de este fast bin para que apunte a la función __free_hook anterior.
• Después, se crea un chunk de tamaño 0x1f8 para recuperar del fast bin el chunk inútil anterior, por lo que se crea otro chunk de tamaño 0x1f8 para obtener un chunk de fast bin en el __free_hook que se sobrescribe con la dirección de la función system.
• Y finalmente, se libera un chunk que contiene la cadena /bin/sh\x00 llamando a la función de eliminación, activando la función __free_hook que apunta a system con /bin/sh\x00 como parámetro.

Referencias

• https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook
• https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md.