# House of Einherjar

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

## Informazioni di base

### Codice

- Controlla l'esempio da [https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c)
- O quello da [https://guyinatuxedo.github.io/42-house_of_einherjar/house_einherjar_exp/index.html#house-of-einherjar-explanation](https://guyinatuxedo.github.io/42-house_of_einherjar/house_einherjar_exp/index.html#house-of-einherjar-explanation) (potresti dover riempire il tcache)

### Obiettivo

- L'obiettivo è allocare memoria in quasi qualsiasi indirizzo specifico.

### Requisiti

- Creare un chunk falso quando vogliamo allocare un chunk:
- Impostare i puntatori per puntare a se stessi per bypassare i controlli di sanità
- Overflow di un byte con un byte nullo da un chunk al successivo per modificare il flag `PREV_INUSE`.
- Indicare nel `prev_size` del chunk abusato off-by-null la differenza tra se stesso e il chunk falso
- La dimensione del chunk falso deve essere stata impostata alla stessa dimensione per bypassare i controlli di sanità
- Per costruire questi chunk, avrai bisogno di un heap leak.

### Attacco

- Un chunk `A` è creato all'interno di un chunk controllato dall'attaccante che punta con `fd` e `bk` al chunk originale per bypassare le protezioni
- Altri 2 chunk (`B` e `C`) sono allocati
- Abusando l'off by one nel chunk `B`, il bit `prev in use` viene ripulito e i dati `prev_size` vengono sovrascritti con la differenza tra il posto in cui il chunk `C` è allocato e il chunk falso `A` generato prima
- Questo `prev_size` e la dimensione nel chunk falso `A` devono essere gli stessi per bypassare i controlli.
- Poi, il tcache viene riempito
- Poi, `C` viene liberato in modo che si consolidi con il chunk falso `A`
- Poi, un nuovo chunk `D` viene creato che inizierà nel chunk falso `A` e coprirà il chunk `B`
- La casa di Einherjar finisce qui
- Questo può essere continuato con un attacco fast bin o avvelenamento Tcache:
- Libera `B` per aggiungerlo al fast bin / Tcache
- `fd` di `B` viene sovrascritto facendolo puntare all'indirizzo target abusando del chunk `D` (poiché contiene `B` all'interno)
- Poi, vengono eseguite 2 malloc e il secondo andrà a **allocare l'indirizzo target**

## Riferimenti e altri esempi

- [https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.35/house_of_einherjar.c)
- **CTF** [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_einherjar/#2016-seccon-tinypad**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_einherjar/#2016-seccon-tinypad)
- Dopo aver liberato i puntatori, non vengono annullati, quindi è ancora possibile accedere ai loro dati. Pertanto, un chunk viene posizionato nel bin non ordinato e vengono rivelati i puntatori che contiene (libc leak) e poi un nuovo heap viene posizionato nel bin non ordinato e viene rivelato un indirizzo heap dal puntatore che ottiene.
- [**baby-talk. DiceCTF 2024**](https://7rocky.github.io/en/ctf/other/dicectf/baby-talk/)
- Bug di overflow di byte nullo in `strtok`.
- Usa House of Einherjar per ottenere una situazione di chunk sovrapposti e finire con avvelenamento Tcache per ottenere una primitiva di scrittura arbitraria.

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