House of Roman

AWS हैकिंग सीखें और अभ्यास करें:HackTricks प्रशिक्षण AWS रेड टीम विशेषज्ञ (ARTE) GCP हैकिंग सीखें और अभ्यास करें: HackTricks प्रशिक्षण GCP रेड टीम विशेषज्ञ (GRTE)

हैकट्रिक्स का समर्थन करें

सदस्यता योजनाएं की जांच करें!
शामिल हों 💬 डिस्कॉर्ड समूह या टेलीग्राम समूह या हमें ट्विटर 🐦 @hacktricks_live** पर फॉलो** करें।
हैकिंग ट्रिक्स साझा करें, PRs सबमिट करके HackTricks और HackTricks Cloud github रेपो में।

मौलिक जानकारी

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

कोड

आप एक उदाहरण https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c में पा सकते हैं।

लक्ष्य

संबंधित पॉइंटर्स का दुरुपयोग करके RCE

आवश्यकताएं

फास्टबिन और अनसॉर्टेड बिन पॉइंटर्स को संपादित करें
12 बिट की यादृच्छिकता को ब्रूट फोर्स करना होगा (0.02% की संभावना) काम करने की

हमले के कदम

भाग 1: फास्टबिन चंक ने __मैलोक_हुक को पॉइंट किया

कई चंक बनाएं:

fastbin_victim (0x60, ऑफसेट 0): बाद में ही हीप पॉइंटर को संपादित करने के लिए UAF चंक।
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 संभावनाएं होती हैं। इसलिए यहां एक बीएफ हमला किया जाता है ताकि टुकड़ा इस प्रकार समाप्त हो: 0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)।

(अधिक जानकारी के लिए बाकी बाइट्स के बारे में व्याख्या देखें how2heap उदाहरण)। यदि बीएफ काम नहीं करता है तो प्रोग्राम बस क्रैश हो जाता है (तो यह काम करने तक फिर से शुरू करें)।

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

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

भाग 2: अव्यवस्थित_बिन हमला

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

Unsorted Bin Attack

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

इसके लिए हम एक चंक प्राप्त करना शुरू करते हैं और इसे अव्यवस्थित बिन में डालते हैं:

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);

Use an UAF in this chunk to point unsorted_bin_ptr->bk to the address of __malloc_hook (we brute forced this previously).

ध्यान दें कि यह हमला अव्यवस्थित बिन को क्षति पहुंचाता है (इसलिए छोटा और बड़ा भी)। इसलिए हम अब केवल फास्ट बिन से आवंटन का उपयोग कर सकते हैं (एक अधिक जटिल कार्यक्रम अन्य आवंटन कर सकता है और क्रैश हो सकता है), और इसे ट्रिगर करने के लिए हमें एक ही आकार का आवंटन करना होगा या प्रोग्राम क्रैश हो जाएगा।

इसलिए, main_arena + 0x68 में __malloc_hook में लिखने के बाद हमें केवल यह करने की आवश्यकता है: malloc(0x80)

चरण 3: __malloc_hook को सिस्टम पर सेट करें

चरण एक में हमने __malloc_hook को समावेश करने वाले एक चंक को नियंत्रित करना समाप्त किया (चरण दो में हमने यहां main_arena + 0x68 लिखने में सफल रहे।

अब, हम malloc_hook_chunk में एक आंशिक ओवरराइट का दुरुपयोग करते हैं ताकि हम वहां लिखे गए libc पते का उपयोग करें (main_arena + 0x68) एक one_gadget पते को दिखाने के लिए।

यहां वहां 12 बिट के यादृच्छिकता का ब्रूटफोर्स करने की आवश्यकता है (अधिक जानकारी how2heap उदाहरण में।)

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

संदर्भ

PreviousHouse of Rabbit NextCommon Binary Exploitation Protections & Bypasses

Last updated 4 months ago