मनमाना डेटा लिखने के लिए एक ढेर ओवरफ्लो का उपयोग करें

Question

मैं एक ढेर अतिप्रवाह हमले की मूल बातें सीखने की कोशिश कर रहा हूं। हम ज्यादातर हमले के आधार पर भ्रष्टाचार या खंड मेटाडेटा में संशोधन का उपयोग करने में रूचि रखते हैं, लेकिन मैं अन्य सुझावों के लिए भी खुला हूं। मुझे पता है कि शोषण का मेरा लक्ष्य printf() फ़ंक्शन पॉइंटर को challenge() फ़ंक्शन पॉइंटर के साथ ओवरराइट करना चाहिए, लेकिन मुझे लगता है कि उस लेखन को कैसे प्राप्त किया जाए। मैं कोड का निम्न भाग जो मैं फायदा उठाने के लिए चाहते हैं, जो glibc 2.11.2 से malloc उपयोग कर रहा है है: जाहिर है

void challenge() 
{ 
     puts("you win\n"); 
} 

int main(int argc, char **argv) 
{ 
     char *inputA, *inputB, *inputC; 

     inputA = malloc(32); 
     inputB = malloc(32); 
     inputC = malloc(32); 

     strcpy(inputA, argv[1]); 
     strcpy(inputB, argv[2]); 
     strcpy(inputC, argv[3]); 

     free(inputC); 
     free(inputB); 
     free(inputA); 

     printf("execute challenge to win\n"); 
} 

, एक आवंटित हिस्सा के मेटाडाटा का एक वास्तविक अधिलेखित को प्राप्त करने तुच्छ है। हालांकि, मैं किसी भी मानक तकनीक का उपयोग करके इस कोड का शोषण करने का कोई तरीका नहीं ढूंढ पाया। मैंने पढ़ा है और से तकनीक को लागू करने का प्रयास किया है:

• कागज: Heap Overflows
  • पर w00w00 हालांकि कागज बहुत स्पष्ट है, unlink तकनीक कुछ समय के लिए अप्रचलित हो गया है।
• Malloc Maleficarum.txt
  • इस पत्र w00w00 दिनों से फायदा उठाने की तकनीक पर फैलता है, और glibc के नए संस्करण के लिए खातों। हालांकि, मुझे नहीं मिला है कि पेपर में विस्तृत 5 तकनीकों को देखते हुए, ऊपर दिया गया कोड उन तकनीकों के लिए किसी भी शर्त से मेल खाता है।
• Understanding the Heap By Breaking it(pdf)
  • पीडीएफ कैसे ढेर काम करता है की एक बहुत अच्छी समीक्षा देता है, लेकिन डबल मुक्त तकनीक पर केंद्रित है।

मैं मूल रूप से, inputC के लिए खंड के आकार मूल्य जोड़ तोड़ इतना है कि यह वापस inputC हिस्सा के सिर की ओर इशारा करके इस कोड का फायदा उठाने की कोशिश की। जब यह काम नहीं करता, तो मैंने इनपुट बी के हिस्से में आगे की ओर इशारा करने की कोशिश की। यही वह समय था जब मुझे एहसास हुआ कि नया ग्लिबैक आकार मूल्य पर एक सैनिटी चेक करता है।

उपयोगकर्ता एक मुफ्त का लाभ उठाने के लिए एक शोषण कैसे तैयार कर सकता है, मानते हैं कि उसके पास आवंटित मूल्यों के लिए आवंटित खंड के मेटाडेटा को संपादित करने की क्षमता है, और उपयोगकर्ता इसे जीओटी में किसी मान को ओवरराइट करने या किसी अन्य मनमानी पते पर लिखने की क्षमता रखता है ?

नोट: जब मैं 'मनमानी पता' लिखता हूं, तो मैं समझता हूं कि स्मृति पृष्ठ केवल पढ़ने या संरक्षित किए जा सकते हैं, मेरा मतलब है कि एक ऐसा पता जिसे मैं मान सकता हूं कि मैं लिख सकता हूं।

Answer 1

नोट: मैं जवाब देने से पहले कहूंगा कि यह पूरी तरह से एक अकादमिक उत्तर है, जिसका उद्देश्य दुर्भावनापूर्ण उद्देश्यों के लिए उपयोग नहीं करना है। मुझे ओपी अभ्यास करने के बारे में पता है और वे खुले स्रोत हैं और इन प्रयोक्ताओं को इन तकनीकों को अस्वीकृत परिस्थितियों में उपयोग करने के लिए प्रोत्साहित करने का इरादा नहीं है।

मैं तकनीक नीचे विस्तार होगा लेकिन आपके संदर्भ के लिए मैं (यह ऊपर अपने लिंक में से एक में संदर्भित है) Vudo malloc चाल पर एक नज़र ले जाएगा क्योंकि मेरी सिंहावलोकन एक छोटी एक होने जा रहा है: http://www.phrack.com/issues.html?issue=57&id=8

यह बताता है कि कैसे मैलोक स्मृति के ब्लॉक बनाते हैं, सूचियों और अन्य चीजों से स्मृति खींचते हैं। विशेष रूप से अनलिंक हमले इस हमले के लिए ब्याज की बात है (नोट: आप सही हैं कि ग्लिबैक अब इस विशेष कारण के लिए आकार पर एक सैनिटी चेक करता है, लेकिन आपको इस अभ्यास के लिए पुराने libc पर होना चाहिए ... विरासत ब्रो)।

पेपर से, एक आवंटित ब्लॉक और एक नि: शुल्क ब्लॉक समान डेटा संरचना का उपयोग करता है, लेकिन डेटा को अलग-अलग संभाला जाता है। यहां देखें:

chunk -> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 
     | prev_size: size of the previous chunk, in bytes (used | 
     | by dlmalloc only if this previous chunk is free)  | 
     +---------------------------------------------------------+ 
     | size: size of the chunk (the number of bytes between | 
     | "chunk" and "nextchunk") and 2 bits status information | 
    mem -> +---------------------------------------------------------+ 
     | fd: not used by dlmalloc because "chunk" is allocated | 
     | (user data therefore starts here)      | 
     + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + 
     | bk: not used by dlmalloc because "chunk" is allocated | 
     | (there may be user data here)       | 
     + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + 
     |               | 
     |               | 
     | user data (may be 0 bytes long)       | 
     |               | 
     |               | 
next -> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 
     | prev_size: not used by dlmalloc because "chunk" is  | 
     | allocated (may hold user data, to decrease wastage)  | 
     +---------------------------------------------------------+ 

आवंटित ब्लॉक एफडी या बीके पॉइंटर्स का उपयोग नहीं करते हैं, लेकिन स्वतंत्र लोग करेंगे। यह बाद में महत्वपूर्ण होगा।आपको यह समझने के लिए पर्याप्त प्रोग्रामिंग पता होना चाहिए कि डौग ली के मॉलोक में "ब्लॉक" को दोगुनी-लिंक्ड सूची में व्यवस्थित किया गया है; नि: शुल्क ब्लॉक के लिए एक सूची है और दूसरा आवंटित लोगों के लिए है (तकनीकी रूप से आकारों के आधार पर मुफ्त में कई सूचियां हैं लेकिन यह कोड अप्रासंगिक है क्योंकि कोड एक ही आकार के ब्लॉक आवंटित करता है)। तो जब आप किसी विशेष ब्लॉक को मुक्त कर रहे हों, तो आपको सूची को सूची में रखने के लिए पॉइंटर्स को ठीक करना होगा।

उदा। मान लीजिए कि आप नीचे दी गई सूची से ब्लॉक y मुक्त कराने रहे हैं:

x <-> y <-> z 

सूचना है कि बीके के लिए धब्बे और fd ऊपर चित्र में आवश्यक संकेत होते हैं सूची के साथ दोहराना चाहते। malloc सूची यह कहता है, अन्य बातों के अलावा के बंद एक ब्लॉक पी लेना चाहता है, तो कोई मैक्रो सूची ठीक करने के लिए:

#define unlink(y, BK, FD) {    
    BK = P->bk;       
    FD = P->fd;       
    FD->bk = BK;       
    BK->fd = FD;       
} 

मैक्रो ही समझना कठिन नहीं है, लेकिन में नोट करने के लिए महत्वपूर्ण बात यह है libc के पुराने संस्करण यह है कि यह आकार या पॉइंटर्स को लिखित होने पर सैनिटी चेक नहीं करता है। आपके मामले में इसका क्या अर्थ है कि किसी भी प्रकार के पते के यादृच्छिकरण के बिना आप ढेर की स्थिति निर्धारित कर सकते हैं और विश्वसनीय रूप से ढेर की स्थिति निर्धारित कर सकते हैं और एक विशिष्ट तरीके से ढेर को बहने से अपने चयन के पते पर मनमाना सूचक को पुनर्निर्देशित कर सकते हैं ।

वहाँ काम करने के लिए हमले प्राप्त करने के लिए आवश्यक कुछ चीजें है:

• अपने ब्लॉक के लिए एफडी सूचक पता आप शून्य से 12 बाइट्स अधिलेखित करना चाहते हैं की ओर इशारा करते है। जब ऑफसेट सूची
• आपकी ब्लॉक का बीके सूचक आपके शेलकोड को इंगित कर रहा है
• आकार को -4 होना आवश्यक है, तो ऑफसेट को संरेखण की सफाई करना है। यह कुछ चीजें हासिल करता है, अर्थात् यह ब्लॉक

में स्थिति बिट्स सेट करता है, इसलिए आपको अपने विशिष्ट उदाहरण में ऑफ़सेट के साथ खेलना होगा, लेकिन सामान्य दुर्भावनापूर्ण प्रारूप जिसे आप पास करने का प्रयास कर रहे हैं यहां स्ट्रैपी प्रारूप का है:

| वैध बफर भरने के लिए जंक | -4 | -4 | addr आप ओवरराइट करना चाहते हैं -12 (0x0C) | addr आप इसके बजाय कॉल करना चाहते हैं

ध्यान दें कि ऋणात्मक संख्या prev_size फ़ील्ड को -4 पर सेट करती है, जो मुक्त रूटिंग का मानना ​​है कि prev_size खंड वास्तव में उस मौजूदा खंड में शुरू होता है जिसे आप नियंत्रित करते हैं/दूषित होते हैं।

और हां, यह उल्लेख किए बिना उचित स्पष्टीकरण पूरा नहीं होगा कि यह हमला ग्लिब के वर्तमान संस्करणों पर काम नहीं करता है; आकार में एक सैनिटी चेक किया गया है और अनलिंक विधि बस काम नहीं करेगी। यह पता यादृच्छिकरण जैसे कमजोरियों के साथ संयोजन में यह हमला विरासत प्रणाली के अलावा कुछ भी व्यवहार्य नहीं है। लेकिन यहां वर्णित विधि यह है कि मैंने यह चुनौती कैसे की;)

Answer 2

हीप ओवरफ्लो खींचने के लिए मुश्किल हैं, और बहुत भारी ढेर-लेआउट निर्भर हैं, हालांकि ऐसा लगता है कि आप विंडोज सीआरटी ढेर के बाद जा रहे हैं, जिसमें विशेष रूप से इस प्रकार के हमले को रोकने के लिए बहुत कम कमी है।

यदि आप वास्तव में इस तरह की चीज करना चाहते हैं, तो आपको WinDbg में कूदने और मुफ्त में क्या हो रहा है यह देखने के लिए स्वतंत्र रूप से फ़ंक्शंस में कदम उठाने की आवश्यकता है, और इसलिए आप किस प्रकार का नियंत्रण कर सकते हैं पिछले मूल्य के ढेर अतिप्रवाह के माध्यम से प्राप्त करें।

मैं आपको उस सामान्य कारण से अधिक विशिष्ट सहायता नहीं दूंगा जो ढेर अतिप्रवाह का प्रदर्शन आमतौर पर रक्षात्मक सुरक्षा के लिए पर्याप्त है - रक्षात्मक सुरक्षा विशेषज्ञ वास्तव में इसका पूरी तरह से शोषण करने की आवश्यकता के बिना एक ढेर अतिप्रवाह की रिपोर्ट कर सकते हैं। एकमात्र लोग जो करते हैं रिमोट कोड निष्पादन के लिए सभी तरह से ढेर-ओवरफ्लो का पूरी तरह से उपयोग करने की आवश्यकता है, लोग आक्रामक पर शोषण कर रहे हैं, और यदि आप ऐसा करना चाहते हैं, तो आप स्वयं ही हैं।

Answer 3

ध्यान दें कि मलोक माललेफारम में समझाया गया अधिकांश तकनीक अब संरक्षित है। ग्लिबैक ने दोहरे मुक्त परिदृश्यों में बहुत कुछ सुधार किया है।

यदि आप मॉलोक माललेफ़ारम तकनीक के बारे में अपना ज्ञान सुधारना चाहते हैं तो मॉलोक डेस-माललेफ़ारम और हाउस ऑफ लॉरे: ब्लैकगेल द्वारा लिखित रीलोडेड पढ़ें। आप इन ग्रंथों को फ्रेक में पा सकते हैं।

Malloc Des-Malleficarum

मैं भी इस पर काम कर रहा हूँ, और मैं तुम्हें करने के लिए कह सकते हैं कि, उदाहरण के लिए, मन की सभा नहीं रह गया है, दोहन कम से कम, के रूप में ग्रंथों में विस्तार से बताया जाता है। हालांकि कोड में जोड़े गए नए प्रतिबंधों को बाईपास करना संभव हो सकता है। जोड़ें कि अपने कोड को निष्पादित करने का सबसे आसान तरीका है .dors पते को ओवरराइट करना है इसलिए कार्यक्रम समाप्त होने के बाद आपका कोड हमेशा निष्पादित किया जाएगा।

यदि आप glibc कोड डाउनलोड करते हैं और malloc के आलोचक जोन का अध्ययन करते हैं, आदि। आपको कोड चेक मिलेगा जो पहले उल्लेखित दस्तावेज़ों में दस्तावेज़ीकृत नहीं हैं। इन चेक को डबल फ्री पार्टी को रोकने के लिए शामिल किया गया था।

दूसरी तरफ, जस्टिन एन फर्ग्यूसन (इसे तोड़कर ढेर को समझना) की प्रस्तुति जो आप यूट्यूब (ब्लैकहैट 2007) में पा सकते हैं, सभी ढेर यांत्रिकी को समझने के लिए सही है, लेकिन मुझे यह स्वीकार करना होगा दिखाए गए तकनीक विश्वसनीय होने से बहुत दूर हैं, लेकिन कम से कम, वह शोषण ढेर करने के लिए एक नया क्षेत्र खोलता है।

Understanding the heap by breaking it

फिर भी, मैं भी इस पर काम कर रहा हूँ, अगर आप मुझसे संपर्क करना चाहते हैं, हम अपने अग्रिम साझा कर सकें। आप overflowedminds.net डोमेन में न्यूलॉग के रूप में मेरे पास पहुंच सकते हैं (मेल पता स्वयं बनाएं ^^)।