Tcache Bin Attack

Reading time: 5 minutes

Basic Information

Per ulteriori informazioni su cosa sia un Tcache bin, controlla questa pagina:

{{#ref}} bins-and-memory-allocations.md {{#endref}}

Prima di tutto, nota che il Tcache è stato introdotto nella versione 2.26 di Glibc.

L'attacco Tcache (noto anche come avvelenamento Tcache) proposto nella pagina di guyinatuxido è molto simile all'attacco fast bin, dove l'obiettivo è sovrascrivere il puntatore al prossimo chunk nel bin all'interno di un chunk liberato a un indirizzo arbitrario, in modo che in seguito sia possibile allocare quell'indirizzo specifico e potenzialmente sovrascrivere i puntatori.

Tuttavia, oggigiorno, se esegui il codice menzionato, riceverai l'errore: malloc(): unaligned tcache chunk detected. Quindi, è necessario scrivere come indirizzo nel nuovo puntatore un indirizzo allineato (o eseguire il binario abbastanza volte affinché l'indirizzo scritto sia effettivamente allineato).

Attacco agli indici Tcache

Di solito è possibile trovare all'inizio dell'heap un chunk contenente la quantità di chunk per indice all'interno del tcache e l'indirizzo del chunk principale di ciascun indice tcache. Se per qualche motivo è possibile modificare queste informazioni, sarebbe possibile far puntare il chunk principale di un indice a un indirizzo desiderato (come __malloc_hook) per poi allocare un chunk della dimensione dell'indice e sovrascrivere i contenuti di __malloc_hook in questo caso.

Esempi

• CTF https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html
• Libc info leak: È possibile riempire i tcache, aggiungere un chunk nella lista non ordinata, svuotare il tcache e ri-allocare il chunk dal bin non ordinato sovrascrivendo solo i primi 8B, lasciando il secondo indirizzo a libc del chunk intatto in modo da poterlo leggere.
• Attacco Tcache: Il binario è vulnerabile a un overflow dell'heap di 1B. Questo sarà abusato per cambiare l'header della dimensione di un chunk allocato rendendolo più grande. Poi, questo chunk sarà liberato, aggiungendolo al tcache di chunk di dimensione falsa. Poi, allochiamo un chunk con la dimensione falsa, e il chunk precedente sarà restituito sapendo che questo chunk era in realtà più piccolo e questo offre l'opportunità di sovrascrivere il prossimo chunk in memoria.
  Abuseremo di questo per sovrascrivere il puntatore FD del prossimo chunk per puntare a malloc_hook, in modo che sia possibile allocare 2 puntatori: prima il puntatore legittimo che abbiamo appena modificato, e poi la seconda allocazione restituirà un chunk in malloc_hook che è possibile abusare per scrivere un one gadget.
• CTF https://guyinatuxedo.github.io/29-tcache/plaid19_cpp/index.html
• Libc info leak: C'è un use after free e un double free. In questo writeup l'autore ha fatto trapelare un indirizzo di libc leggendo l'indirizzo di un chunk posizionato in un bin piccolo (come se lo si stesse facendo trapelare dal bin non ordinato ma dal piccolo).
• Attacco Tcache: Un Tcache viene eseguito tramite un double free. Lo stesso chunk viene liberato due volte, quindi all'interno del Tcache il chunk punterà a se stesso. Poi, viene allocato, il suo puntatore FD viene modificato per puntare al free hook e poi viene allocato di nuovo, quindi il prossimo chunk nella lista sarà nel free hook. Poi, questo viene anche allocato ed è possibile scrivere l'indirizzo di system qui, quindi quando un malloc contenente "/bin/sh" viene liberato otteniamo una shell.
• CTF https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps0/index.html
• La principale vulnerabilità qui è la capacità di free qualsiasi indirizzo nell'heap indicando il suo offset.
• Attacco agli indici Tcache: È possibile allocare e liberare un chunk di una dimensione che, quando memorizzato all'interno del chunk tcache (il chunk con le informazioni dei bin tcache), genererà un indirizzo con il valore 0x100. Questo perché il tcache memorizza la quantità di chunk in ciascun bin in byte diversi, quindi un chunk in un indice specifico genera il valore 0x100.
• Poi, questo valore sembra che ci sia un chunk di dimensione 0x100. Permettendo di abusarne liberando questo indirizzo. Questo aggiungerà quell'indirizzo all'indice dei chunk di dimensione 0x100 nel tcache.
• Poi, allocando un chunk di dimensione 0x100, l'indirizzo precedente verrà restituito come un chunk, permettendo di sovrascrivere altri indici tcache.
  Ad esempio, mettendo l'indirizzo di malloc hook in uno di essi e allocando un chunk della dimensione di quell'indice garantirà un chunk nel calloc hook, che consente di scrivere un one gadget per ottenere una shell.
• CTF https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps1/index.html
• Stessa vulnerabilità di prima con una restrizione extra.
• Attacco agli indici Tcache: Attacco simile a quello precedente ma utilizzando meno passaggi liberando il chunk che contiene le informazioni tcache in modo che il suo indirizzo venga aggiunto all'indice tcache della sua dimensione, quindi è possibile allocare quella dimensione e ottenere le informazioni del chunk tcache come un chunk, il che consente di aggiungere il free hook come indirizzo di un indice, allocarlo e scrivere un one gadget su di esso.
• Math Door. HTB Cyber Apocalypse CTF 2023
• Write After Free per aggiungere un numero al puntatore fd.
• È necessaria molta heap feng-shui in questa sfida. Lo writeup mostra come controllare la testa della lista libera Tcache sia molto utile.
• Glibc leak tramite stdout (FSOP).
• Avvelenamento Tcache per ottenere una scrittura arbitraria primitiva.