hacktricks/binary-exploitation/libc-heap/house-of-force.md

House of Force

{% hint style="success" %} Impara e pratica l'Hacking su AWS: HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'Hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
• Condividi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud github repos.

{% endhint %}

Informazioni di Base

Codice

• Questa tecnica è stata corretta (qui) e produce questo errore: malloc(): corrupted top size
• Puoi provare il codice da qui per testarlo se vuoi.

Obiettivo

• L'obiettivo di questo attacco è essere in grado di allocare un chunk in un indirizzo specifico.

Requisiti

• Un overflow che permette di sovrascrivere la dimensione dell'intestazione del top chunk (es. -1).
• Essere in grado di controllare la dimensione dell'allocazione dell'heap

Attacco

Se un attaccante vuole allocare un chunk nell'indirizzo P per sovrascrivere un valore qui. Inizia sovrascrivendo la dimensione del top chunk con -1 (forse con un overflow). Questo garantisce che malloc non utilizzerà mmap per nessuna allocazione poiché il Top chunk avrà sempre abbastanza spazio.

Successivamente, calcola la distanza tra l'indirizzo del top chunk e lo spazio target da allocare. Questo perché verrà eseguita un'allocazione malloc con quella dimensione per spostare il top chunk in quella posizione. In questo modo la differenza/dimensione può essere facilmente calcolata:

// From https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c#L59C2-L67C5
/*
* The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
* new_top = old_top + nb
* nb = new_top - old_top
* req + 2sizeof(long) = new_top - old_top
* req = new_top - old_top - 2sizeof(long)
* req = target - 2sizeof(long) - old_top - 2sizeof(long)
* req = target - old_top - 4*sizeof(long)
*/

Pertanto, allocare una dimensione di target - old_top - 4*sizeof(long) (i 4 long sono a causa dei metadati del chunk superiore e del nuovo chunk quando allocato) sposterà il chunk superiore all'indirizzo che vogliamo sovrascrivere.
Successivamente, eseguire un'altra malloc per ottenere un chunk all'indirizzo target.

Riferimenti ed Altri Esempi

• https://github.com/shellphish/how2heap/tree/master
• https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/
• https://heap-exploitation.dhavalkapil.com/attacks/house_of_force
• https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c
• https://guyinatuxedo.github.io/41-house_of_force/house_force_exp/index.html
• https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/#hitcon-training-lab-11
• L'obiettivo di questo scenario è un ret2win dove è necessario modificare l'indirizzo di una funzione che verrà chiamata dall'indirizzo della funzione ret2win
• Il binario ha un overflow che può essere sfruttato per modificare la dimensione del top chunk, che viene modificata in -1 o p64(0xffffffffffffffff)
• Quindi, viene calcolato l'indirizzo del luogo in cui esiste il puntatore da sovrascrivere, e la differenza dalla posizione attuale del top chunk a quel punto viene allocata con malloc
• Infine viene allocato un nuovo chunk che conterrà questo target desiderato all'interno che viene sovrascritto dalla funzione ret2win
• https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp
• Nel Input your name: c'è una vulnerabilità iniziale che consente di ottenere un leak di un indirizzo dall'heap
• Poi nelle funzionalità Org: e Host:, è possibile riempire i 64B del puntatore s quando viene richiesto il nome dell'org, che nello stack è seguito dall'indirizzo di v2, che è poi seguito dal nome dell'host indicato. Poiché poi, strcpy copierà i contenuti di s in un chunk di dimensione 64B, è possibile sovrascrivere la dimensione del top chunk con i dati inseriti nel nome dell'host.
• Ora che è possibile una scrittura arbitraria, il GOT di atoi è stato sovrascritto con l'indirizzo di printf. quindi è possibile ottenere il leak dell'indirizzo di IO_2_1_stderr con %24$p. E con questo leak di libc è stato possibile sovrascrivere di nuovo il GOT di atoi con l'indirizzo di system e chiamarlo passando come parametro /bin/sh
• Un metodo alternativo proposto in questo altro writeup, è sovrascrivere free con puts, e quindi aggiungere l'indirizzo di atoi@got, nel puntatore che verrà successivamente liberato in modo che venga leakato e con questo leak sovrascrivere di nuovo atoi@got con system e chiamarlo con /bin/sh.
• https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html
• C'è un UAF che consente di riutilizzare un chunk che è stato liberato senza cancellare il puntatore. Poiché ci sono alcuni metodi di lettura, è possibile ottenere un leak di un indirizzo libc scrivendo un puntatore alla funzione free nel GOT qui e quindi chiamando la funzione di lettura.
• Quindi, è stato utilizzato House of force (abusando dell'UAF) per sovrascrivere la dimensione dello spazio sinistro con un -1, allocare un chunk abbastanza grande per arrivare al free hook, e quindi allocare un altro chunk che conterrà il free hook. Quindi, scrivere nel hook l'indirizzo di system, scrivere in un chunk "/bin/sh" e infine liberare il chunk con quel contenuto di stringa.