WWW2Exec - __malloc_hook & __free_hook

Reading time: 4 minutes

Malloc Hook

Come puoi vedere nel sito ufficiale GNU, la variabile __malloc_hook è un puntatore che punta all'indirizzo di una funzione che verrà chiamata ogni volta che viene chiamato malloc(), memorizzato nella sezione dati della libreria libc. Pertanto, se questo indirizzo viene sovrascritto con un One Gadget, ad esempio, e viene chiamato malloc, il One Gadget verrà chiamato.

Per chiamare malloc è possibile aspettare che il programma lo chiami o chiamando printf("%10000$c"), che alloca troppi byte, facendo sì che libc chiami malloc per allocarli nel heap.

Ulteriori informazioni su One Gadget in:

{{#ref}} ../rop-return-oriented-programing/ret2lib/one-gadget.md {{#endref}}

Free Hook

Questo è stato abusato in uno degli esempi della pagina che sfrutta un attacco fast bin dopo aver abusato di un attacco unsorted bin:

{{#ref}} ../libc-heap/unsorted-bin-attack.md {{#endref}}

È possibile trovare l'indirizzo di __free_hook se il binario ha simboli con il seguente comando:

gef➤  p &__free_hook

Nel post puoi trovare una guida passo passo su come localizzare l'indirizzo del free hook senza simboli. In sintesi, nella funzione 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 

Nel punto di interruzione menzionato nel codice precedente, in $eax si troverà l'indirizzo del free hook.

Ora viene eseguito un fast bin attack:

• Prima di tutto si scopre che è possibile lavorare con fast chunks di dimensione 200 nella posizione __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

• Se riusciamo a ottenere un fast chunk di dimensione 0x200 in questa posizione, sarà possibile sovrascrivere un puntatore a funzione che verrà eseguito.
• Per questo, viene creato un nuovo chunk di dimensione 0xfc e la funzione unita viene chiamata con quel puntatore due volte, in questo modo otteniamo un puntatore a un chunk liberato di dimensione 0xfc*2 = 0x1f8 nel fast bin.
• Poi, la funzione di modifica viene chiamata in questo chunk per modificare l'indirizzo fd di questo fast bin per puntare alla precedente funzione __free_hook.
• Successivamente, viene creato un chunk di dimensione 0x1f8 per recuperare dal fast bin il precedente chunk inutile, quindi viene creato un altro chunk di dimensione 0x1f8 per ottenere un fast bin chunk nella __free_hook che viene sovrascritto con l'indirizzo della funzione system.
• E infine, viene liberato un chunk contenente la stringa /bin/sh\x00 chiamando la funzione di eliminazione, attivando la funzione __free_hook che punta a system con /bin/sh\x00 come parametro.

Riferimenti

• 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.