mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
113 lines
10 KiB
Markdown
113 lines
10 KiB
Markdown
# House of Roman
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|
|
|
|
## Basic Information
|
|
|
|
यह एक बहुत ही दिलचस्प तकनीक थी जिसने नकली फास्टबिन, अनसॉर्टेड_बिन हमले और सापेक्ष ओवरराइट के माध्यम से RCE की अनुमति दी। हालाँकि इसे [**पैच**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c) किया गया है।
|
|
|
|
### Code
|
|
|
|
- आप एक उदाहरण [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c) पर पा सकते हैं।
|
|
|
|
### Goal
|
|
|
|
- सापेक्ष पॉइंटर्स का दुरुपयोग करके RCE प्राप्त करना
|
|
|
|
### Requirements
|
|
|
|
- फास्टबिन और अनसॉर्टेड बिन पॉइंटर्स को संपादित करें
|
|
- 12 बिट की यादृच्छिकता को ब्रूट फोर्स किया जाना चाहिए (काम करने की 0.02% संभावना)
|
|
|
|
## Attack Steps
|
|
|
|
### Part 1: Fastbin Chunk points to \_\_malloc_hook
|
|
|
|
कई चंक्स बनाएं:
|
|
|
|
- `fastbin_victim` (0x60, ऑफसेट 0): UAF चंक जिसे बाद में हीप पॉइंटर को LibC मान की ओर इंगित करने के लिए संपादित किया जाएगा।
|
|
- `chunk2` (0x80, ऑफसेट 0x70): अच्छे संरेखण के लिए
|
|
- `main_arena_use` (0x80, ऑफसेट 0x100)
|
|
- `relative_offset_heap` (0x60, ऑफसेट 0x190): 'main_arena_use' चंक पर सापेक्ष ऑफसेट
|
|
|
|
फिर `free(main_arena_use)` करें जो इस चंक को अनसॉर्टेड सूची में रखेगा और `fd` और `bk` पॉइंटर्स में `main_arena + 0x68` का एक पॉइंटर प्राप्त करेगा।
|
|
|
|
अब एक नया चंक `fake_libc_chunk(0x60)` आवंटित किया गया है क्योंकि इसमें `fd` और `bk` में `main_arena + 0x68` के पॉइंटर्स होंगे।
|
|
|
|
फिर `relative_offset_heap` और `fastbin_victim` को मुक्त किया जाता है।
|
|
```c
|
|
/*
|
|
Current heap layout:
|
|
0x0: fastbin_victim - size 0x70
|
|
0x70: alignment_filler - size 0x90
|
|
0x100: fake_libc_chunk - size 0x70 (contains a fd ptr to main_arena + 0x68)
|
|
0x170: leftover_main - size 0x20
|
|
0x190: relative_offset_heap - size 0x70
|
|
|
|
bin layout:
|
|
fastbin: fastbin_victim -> relative_offset_heap
|
|
unsorted: leftover_main
|
|
*/
|
|
```
|
|
- `fastbin_victim` का `fd` `relative_offset_heap` की ओर इशारा कर रहा है
|
|
- `relative_offset_heap` एक ऑफसेट है जो `fake_libc_chunk` से दूरी को दर्शाता है, जिसमें `main_arena + 0x68` की ओर एक पॉइंटर होता है
|
|
- केवल `fastbin_victim.fd` के अंतिम बाइट को बदलकर, `fastbin_victim` को `main_arena + 0x68` की ओर इशारा करना संभव है
|
|
|
|
पिछले कार्यों के लिए, हमलावर को `fastbin_victim` के fd पॉइंटर को संशोधित करने में सक्षम होना चाहिए।
|
|
|
|
फिर, `main_arena + 0x68` इतना दिलचस्प नहीं है, इसलिए इसे संशोधित करें ताकि पॉइंटर **`__malloc_hook`** की ओर इशारा करे।
|
|
|
|
ध्यान दें कि `__memalign_hook` आमतौर पर `0x7f` से शुरू होता है और इसके पहले शून्य होते हैं, फिर इसे `0x70` फास्ट बिन में एक मान के रूप में फेक करना संभव है। क्योंकि पते के अंतिम 4 बिट **यादृच्छिक** होते हैं, इसलिए मान के अंत में इशारा करने के लिए `2^4=16` संभावनाएँ होती हैं। इसलिए यहां एक BF हमला किया जाता है ताकि चंक इस तरह समाप्त हो: **`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`।**
|
|
|
|
(बाकी बाइट्स के बारे में अधिक जानकारी के लिए [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ उदाहरण](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c) में व्याख्या देखें)। यदि BF काम नहीं करता है, तो प्रोग्राम बस क्रैश हो जाता है (इसलिए तब तक फिर से शुरू करें जब तक यह काम न करे)।
|
|
|
|
फिर, 2 mallocs किए जाते हैं ताकि 2 प्रारंभिक फास्ट बिन चंक्स को हटाया जा सके और एक तीसरा आवंटित किया जाता है ताकि **`__malloc_hook:`** में एक चंक प्राप्त किया जा सके।
|
|
```c
|
|
malloc(0x60);
|
|
malloc(0x60);
|
|
uint8_t* malloc_hook_chunk = malloc(0x60);
|
|
```
|
|
### Part 2: Unsorted_bin हमला
|
|
|
|
अधिक जानकारी के लिए आप देख सकते हैं:
|
|
|
|
{{#ref}}
|
|
unsorted-bin-attack.md
|
|
{{#endref}}
|
|
|
|
लेकिन मूल रूप से यह `chunk->bk` में निर्दिष्ट किसी भी स्थान पर `main_arena + 0x68` लिखने की अनुमति देता है। और हमले के लिए हम `__malloc_hook` चुनते हैं। फिर, इसे ओवरराइट करने के बाद हम एक सापेक्ष ओवरराइट का उपयोग करेंगे) एक `one_gadget` की ओर इशारा करने के लिए।
|
|
|
|
इसके लिए हम एक चंक प्राप्त करना शुरू करते हैं और इसे **unsorted bin** में डालते हैं:
|
|
```c
|
|
uint8_t* unsorted_bin_ptr = malloc(0x80);
|
|
malloc(0x30); // Don't want to consolidate
|
|
|
|
puts("Put chunk into unsorted_bin\n");
|
|
// Free the chunk to create the UAF
|
|
free(unsorted_bin_ptr);
|
|
```
|
|
इस भाग में UAF का उपयोग करें ताकि `unsorted_bin_ptr->bk` को `__malloc_hook` के पते पर इंगित किया जा सके (हमने इसे पहले ब्रूट फोर्स किया था)।
|
|
|
|
> [!CAUTION]
|
|
> ध्यान दें कि यह हमला असंरचित बिन को भ्रष्ट करता है (इसलिए छोटे और बड़े भी)। इसलिए हम केवल **अब तेज बिन से आवंटन का उपयोग कर सकते हैं** (एक अधिक जटिल प्रोग्राम अन्य आवंटन कर सकता है और क्रैश हो सकता है), और इसे ट्रिगर करने के लिए हमें **उसी आकार का आवंटन करना होगा या प्रोग्राम क्रैश हो जाएगा।**
|
|
|
|
तो, `__malloc_hook` में `main_arena + 0x68` के लिखने को ट्रिगर करने के लिए, हमें `__malloc_hook` को `unsorted_bin_ptr->bk` में सेट करने के बाद बस यह करना है: **`malloc(0x80)`**
|
|
|
|
### चरण 3: \_\_malloc_hook को सिस्टम पर सेट करें
|
|
|
|
पहले चरण में, हम `__malloc_hook` वाले एक भाग को नियंत्रित करने में सफल रहे (चर `malloc_hook_chunk` में) और दूसरे चरण में हम यहां `main_arena + 0x68` लिखने में सफल रहे।
|
|
|
|
अब, हम `malloc_hook_chunk` में आंशिक ओवरराइट का दुरुपयोग करते हैं ताकि हम वहां लिखे गए libc पते (`main_arena + 0x68`) का उपयोग करके **एक `one_gadget` पते** को इंगित कर सकें।
|
|
|
|
यहां **12 बिट की यादृच्छिकता को ब्रूटफोर्स करना आवश्यक है** (अधिक जानकारी के लिए [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ उदाहरण](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c) में)।
|
|
|
|
अंत में, एक बार सही पता ओवरराइट हो जाने पर, **`malloc` कॉल करें और `one_gadget` को ट्रिगर करें।**
|
|
|
|
## संदर्भ
|
|
|
|
- [https://github.com/shellphish/how2heap](https://github.com/shellphish/how2heap)
|
|
- [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)
|
|
- [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_roman/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_roman/)
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|