House of Roman
मौलिक जानकारी
यह एक बहुत दिलचस्प तकनीक थी जो फेक फास्टबिन्स, अनसॉर्टेड बिन हमला और संबंधित ओवरराइट के माध्यम से डेटा लीक के बिना 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
को मुक्त कर दिया गया है।
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:
में प्राप्त करने के लिए।
भाग 2: अव्यवस्थित_बिन हमला
अधिक जानकारी के लिए आप यहाँ जांच सकते हैं:
Unsorted Bin Attackलेकिन मूल रूप से यह chunk->bk
में निर्दिष्ट करके किसी भी स्थान पर main_arena + 0x68
लिखने की अनुमति देता है। और हम हमले के लिए __malloc_hook
का चयन करते हैं। फिर, इसे ओवरराइट करने के बाद हम एक रिलेटिव ओवरराइट का उपयोग करेंगे) एक one_gadget
को इंगित करने के लिए।
इसके लिए हम एक चंक प्राप्त करना शुरू करते हैं और इसे अव्यवस्थित बिन में डालते हैं:
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
को ट्रिगर करें।
संदर्भ
Last updated