House of Roman

Reading time: 6 minutes

Basic Information

यह एक बहुत ही दिलचस्प तकनीक थी जिसने नकली फास्टबिन, अनसॉर्टेड_बिन हमले और सापेक्ष ओवरराइट के माध्यम से RCE की अनुमति दी। हालाँकि इसे पैच किया गया है।

Code

• आप एक उदाहरण 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 को मुक्त किया जाता है।

/*
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 उदाहरण में व्याख्या देखें)। यदि BF काम नहीं करता है, तो प्रोग्राम बस क्रैश हो जाता है (इसलिए तब तक फिर से शुरू करें जब तक यह काम न करे)।

फिर, 2 mallocs किए जाते हैं ताकि 2 प्रारंभिक फास्ट बिन चंक्स को हटाया जा सके और एक तीसरा आवंटित किया जाता है ताकि __malloc_hook: में एक चंक प्राप्त किया जा सके।

malloc(0x60);
malloc(0x60);
uint8_t* malloc_hook_chunk = malloc(0x60);

Part 2: Unsorted_bin हमला

अधिक जानकारी के लिए आप देख सकते हैं:

Unsorted Bin Attack

लेकिन मूल रूप से यह chunk->bk में निर्दिष्ट किसी भी स्थान पर main_arena + 0x68 लिखने की अनुमति देता है। और हमले के लिए हम __malloc_hook चुनते हैं। फिर, इसे ओवरराइट करने के बाद हम एक सापेक्ष ओवरराइट का उपयोग करेंगे) एक one_gadget की ओर इशारा करने के लिए।

इसके लिए हम एक चंक प्राप्त करना शुरू करते हैं और इसे unsorted bin में डालते हैं:

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 के पते पर इंगित किया जा सके (हमने इसे पहले ब्रूट फोर्स किया था)।

तो, __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 उदाहरण में)।

अंत में, एक बार सही पता ओवरराइट हो जाने पर, malloc कॉल करें और one_gadget को ट्रिगर करें।

संदर्भ

• https://github.com/shellphish/how2heap
• 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/