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

House of Force

Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

• Se vuoi vedere la tua azienda pubblicizzata in HackTricks o scaricare HackTricks in PDF Controlla i PIANI DI ABBONAMENTO!
• Ottieni il merchandising ufficiale di PEASS & HackTricks
• Scopri La Famiglia PEASS, la nostra collezione di NFT esclusivi
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
• Condividi i tuoi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud github repos.

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 è quello di poter 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.

Quindi, 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. Ecco come può essere facilmente calcolata la differenza/dimensione:

// 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)
*/

Quindi, 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, fare un altro malloc per ottenere un chunk contenente l'inizio dei dati da scrivere 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. è 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.