एमआईटी पाठ्यक्रम "कंप्यूटर सिस्टम सुरक्षा"। व्याख्यान 3: बफर ओवरफ्लो: शोषण और संरक्षण, भाग 2

मैसाचुसेट्स इंस्टीट्यूट ऑफ टेक्नोलॉजी। व्याख्यान पाठ्यक्रम # 6.858। "कंप्यूटर सिस्टम की सुरक्षा।" निकोलाई ज़ेल्डोविच, जेम्स मिकेंस। 2014 साल

कंप्यूटर सिस्टम सुरक्षा सुरक्षित कंप्यूटर सिस्टम के विकास और कार्यान्वयन पर एक कोर्स है। व्याख्यान खतरे के मॉडल को कवर करते हैं, हमले जो सुरक्षा से समझौता करते हैं, और हाल के वैज्ञानिक कार्यों के आधार पर सुरक्षा तकनीक। विषयों में ऑपरेटिंग सिस्टम (OS) सुरक्षा, सुविधाएँ, सूचना प्रवाह प्रबंधन, भाषा सुरक्षा, नेटवर्क प्रोटोकॉल, हार्डवेयर सुरक्षा और वेब अनुप्रयोग सुरक्षा शामिल हैं।

व्याख्यान 1: "परिचय: खतरे के मॉडल" भाग 1 / भाग 2 / भाग 3
व्याख्यान 2: "हैकर हमलों का नियंत्रण" भाग 1 / भाग 2 / भाग 3
व्याख्यान 3: "बफर ओवरफ्लो: शोषण और संरक्षण" भाग 1 / भाग 2 / भाग 3

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

हमलावर लाइनों के सटीक स्थान को निर्धारित नहीं कर सकता है, वह बस 10 एमबी लाइनों के शेल कोड का चयन करता है और एक मनमाना कूदता है। और अगर वह किसी तरह से रिट पॉइंटर्स को नियंत्रित कर सकता है, तो एक मौका है कि वह शेल कोड में "लैंड" करेगा।



आप एनओपी स्लाइड , एनओपी स्लेज या एनओपी रैंप नामक एक ट्रिक का उपयोग कर सकते हैं, जहां एनओपी बिना ऑपरेशन के निर्देश , या खाली, निष्क्रिय कमांड है। इसका मतलब है कि जब भी प्रोग्राम स्लाइड पर कहीं भी मेमोरी एड्रेस पर जाता है, तो प्रोसेसर कमांड निष्पादन प्रवाह "स्लिप" को उसके अंतिम, वांछित गंतव्य पर ले जाता है।

कल्पना करें कि यदि आपके पास शेल कोड की एक पंक्ति है और आप उस लाइन पर एक यादृच्छिक स्थान पर जाते हैं, तो यह काम नहीं कर सकता है, क्योंकि यह आपको हमले को सही तरीके से तैनात करने की अनुमति नहीं देता है।

लेकिन हो सकता है कि आपके द्वारा ढेर में डाला गया सामान मूल रूप से एनओपी का सिर्फ एक टन हो, और बहुत अंत में, आपके पास शेल कोड हो। यह वास्तव में बहुत स्मार्ट है, क्योंकि इसका मतलब है कि अब आप वास्तव में सही जगह पर पहुंच सकते हैं जहां आप कूद रहे हैं। क्योंकि यदि आप इनमें से किसी एक NOP में कूदते हैं, तो यह "बूम, बूम, बूम, बूम, बूम, बूम, बूम" होता है, और फिर आप शेल कोड में आ जाते हैं।

ऐसा लगता है कि लोग इसके साथ आते हैं, जिसे आप शायद हमारी टीम में देखते हैं। वे ऐसा कुछ आविष्कार करते हैं, और यही समस्या है। तो यह आपके कोड को यादृच्छिक बनाने के द्वारा कुछ यादृच्छिक चीजों को प्राप्त करने का एक और तरीका है, अगर यह समझ में आता है।

इसलिए, हमने कुछ प्रकार की यादृच्छिकता पर चर्चा की है जिसका उपयोग आप कर सकते हैं। कुछ बेवकूफी भरे विचार भी लोगों में उठे। तो अब आप जानते हैं कि जब आप सिस्टम कॉल करना चाहते हैं, उदाहरण के लिए, syscall libc फ़ंक्शन का उपयोग करके, आप मूल रूप से किसी भी विशिष्ट संख्या में पास होते हैं जो सिस्टम कॉल का प्रतिनिधित्व करता है जिसे आप बनाना चाहते हैं। तो शायद कांटा फ़ंक्शन 7 है, नींद 8 है, या ऐसा कुछ है।

इसका मतलब यह है कि अगर कोई हमलावर इस syscall निर्देश के पते का पता लगा सकता है और किसी भी तरह से प्राप्त कर सकता है, तो वह वास्तव में सिस्टम कॉल नंबर को केवल उस स्थान पर प्रतिस्थापित कर सकता है जिसका वे सीधे उपयोग करना चाहते हैं। आप कल्पना कर सकते हैं कि हर बार जब प्रोग्राम चलता है, तो आप वास्तव में हमलावर के कब्जे को जटिल बनाने के लिए, वैध सिसकॉल को syscall संख्याओं का एक गतिशील असाइनमेंट बनाते हैं।



हार्डवेयर को बदलने के लिए कुछ अवांट-गार्ड सुझाव भी हैं ताकि उपकरण में xor एन्क्रिप्शन कुंजी हो, जिसका उपयोग xx डायनामिक फ़ंक्शन के लिए किया जाता है। कल्पना करें कि हर बार जब आप एक कार्यक्रम संकलित करते हैं, तो सभी अनुदेश कोड एक निश्चित xor कुंजी प्राप्त करते हैं। यह कुंजी उपकरण रजिस्टर में संग्रहीत की जाती है जब आप शुरू में प्रोग्राम डाउनलोड करते हैं, और उसके बाद, जब भी आप निर्देश को निष्पादित करते हैं, तो उपकरण इस निर्देश के साथ जारी रखने से पहले स्वचालित रूप से इसके साथ xor ऑपरेशन करता है। इस दृष्टिकोण के बारे में अच्छी बात यह है कि अब, भले ही कोई हमलावर शेल कोड उत्पन्न कर सकता है, वह इस कुंजी को नहीं पहचान सकेगा। इसलिए उसके लिए यह पता लगाना बहुत मुश्किल हो जाएगा कि वास्तव में उसे स्मृति में रखने की क्या जरूरत है।

श्रोता: लेकिन अगर वह कोड प्राप्त कर सकता है, तो वह कोड को वापस एक निर्देश में बदलने के लिए xor का भी उपयोग कर सकता है।

प्रोफेसर: हाँ, यह विहित समस्या है, सही है। यह कुछ हद तक बीआरपी हमलों के दौरान होता है, जब हम कोड के स्थान को यादृच्छिक करने के लिए लगते हैं, लेकिन हमलावर इसे "महसूस" कर सकता है और पता लगा सकता है कि क्या हो रहा है। एक कल्पना कर सकता है कि, उदाहरण के लिए, यदि कोई हमलावर कोड के कुछ उप-अनुक्रम को जानता है, जो वह द्विआधारी फ़ाइल में खोजने की उम्मीद करता है, तो वह कुंजी को निकालने के लिए इस फ़ाइल के लिए xor ऑपरेशन का उपयोग करने का प्रयास करेगा।

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

अब हम ROP , रिवर्स-ओरिएंटेड प्रोग्रामिंग के बारे में बात करेंगे। आज मैंने आपको पहले ही बता दिया कि यह पता स्थान को यादृच्छिक बनाने और डेटा को निष्पादित करने से रोकने के संदर्भ में क्या दर्शाता है - यह पढ़ रहा है, लिख रहा है, और निष्पादित कर रहा है। ये वास्तव में बहुत शक्तिशाली चीजें हैं। क्योंकि यादृच्छिककरण एक हमलावर समझ की संभावना को रोकता है जहां हमारे हार्ड-कोडेड पते हैं। और डेटा के निष्पादन को रोकने की क्षमता सुनिश्चित करती है कि भले ही आप शेल कोड को स्टैक पर रखें, एक हमलावर सिर्फ इसे कूद नहीं सकता है और इसे निष्पादित नहीं कर सकता है।

यह सब काफी प्रगतिशील दिखता है, लेकिन हैकर्स लगातार ऐसे प्रगतिशील रक्षा समाधानों के खिलाफ हमले के तरीके विकसित कर रहे हैं।

तो रिवर्स-उन्मुख प्रोग्रामिंग का सार क्या है?

क्या होगा अगर, हमले के दौरान सिर्फ नए कोड बनाने के बजाय, एक हमलावर कोड के मौजूदा टुकड़ों को जोड़ सकता है और फिर उन्हें एक असामान्य तरीके से एक साथ जोड़ सकता है? आखिरकार, हम जानते हैं कि कार्यक्रम में ऐसे कोड के टन शामिल हैं।



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

आइए एक बहुत ही सरल उदाहरण देखें जो आपको पहली बार में परिचित होगा, लेकिन फिर जल्दी से कुछ पागल हो जाएगा।

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



तो, हम जानते हैं कि यहां बफर ओवरफ्लो समस्याओं के बिना होता है। लेकिन दिलचस्प बात यह है कि हमारे पास यह रन शेल फ़ंक्शन है, लेकिन बफर ओवरफ्लो के आधार पर इसे प्राप्त करना मुश्किल है। कोई हमलावर इस रन शेल कमांड को कैसे लागू कर सकता है?

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

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



जैसा कि मैंने कहा, हमले के दौरान, GDB का उपयोग यह पता लगाने के लिए किया गया था कि रन शेल का पता क्या है । इस प्रकार, जब बफर ओवरफ्लो होता है, हम बस रन शेल के पते को दाईं ओर यहां रख सकते हैं। यह वास्तव में एक काफी सरल विस्तार है जो हम पहले से ही जानते हैं कि कैसे करना है। अनिवार्य रूप से, इसका मतलब है कि अगर हमारे पास एक कमांड है जो शेल को लॉन्च करता है, और अगर हम बाइनरी फ़ाइल को इकट्ठा कर सकते हैं यह पता लगाने के लिए कि यह पता कहाँ है, तो हम इसे केवल स्टैक के निचले भाग में स्थित इस अतिप्रवाह सरणी में रख सकते हैं। यह बहुत सरल है।

तो, यह एक अत्यंत तुच्छ उदाहरण था, क्योंकि प्रोग्रामर ने किसी पागल कारण से, इस समारोह को यहां रखा, जिससे हमलावर एक वास्तविक उपहार पेश कर सके।
अब मान लीजिए कि इस चीज़ को run_shell कहने के बजाय, हम इसे run_boring कहेंगे , और फिर यह बस / bin / ls कमांड चलाता है। हालाँकि, हमने कुछ भी नहीं खोया, क्योंकि हमारे पास शीर्ष पर * bash_path स्ट्रिंग स्ट्रिंग होगा, जो हमें इस बिन / बैश का रास्ता बताएगा।



तो इस बारे में सबसे दिलचस्प बात यह है कि एक हमलावर जो ls को चलाना चाहता है, वह प्रोग्राम को "पार्स" कर सकता है और run_boring का स्थान जान सकता है , और यह बिल्कुल भी मज़ेदार नहीं है। लेकिन वास्तव में, हमारे पास मेमोरी में एक पंक्ति होती है जो शेल के पथ को इंगित करती है, इसके अलावा, हम कुछ और दिलचस्प जानते हैं। यह है कि भले ही प्रोग्राम / बिन / एलएस तर्क के साथ सिस्टम को कॉल नहीं करता है, फिर भी यह किसी प्रकार का कॉल करता है।

तो, हम जानते हैं कि सिस्टम को किसी तरह इस प्रोग्राम - सिस्टम ("/ bin / ls") से जोड़ा जाना चाहिए। इसलिए, हम वास्तव में इस चार * bash_path तर्क के साथ सिस्टम को जोड़ने के लिए इन दो शून्य संचालन का उपयोग कर सकते हैं। पहली चीज जो हम करते हैं वह जीडीबी में जाती है और यह पता लगाती है कि बाइनरी प्रक्रिया की छवि में यह सिस्टम ("बिन / एलएस") कहां स्थित है। तो, आप बस GDB पर जाएं , बस print_system टाइप करें और इसके ऑफसेट के बारे में जानकारी प्राप्त करें। यह बहुत आसान है, और आप bash_path के लिए भी ऐसा कर सकते हैं। यही है, आप बस यह पता लगाने के लिए GDB का उपयोग करते हैं कि यह चीज़ कहाँ रहती है।

एक बार जब आप कर लेते हैं, तो आपको कुछ और करने की जरूरत है। क्योंकि अब हमें वास्तव में किसी भी तरह से यह पता लगाने की जरूरत है कि हमने जो तर्क चुना है, उसका उपयोग करके सिस्टम को कैसे लागू किया जाए। और जिस तरह से हम ऐसा करते हैं वह अनिवार्य रूप से सिस्टम के लिए कॉलिंग फ्रेम को गलत साबित करता है। यदि आपको याद है, तो एक फ्रेम वह है जो स्टैक कॉल को लागू करने के लिए कंपाइलर और हार्डवेयर दोनों का उपयोग करता है।

हम स्टैक पर कुछ व्यवस्थित करना चाहते हैं जैसे मैंने इस आंकड़े में दर्शाया है। वास्तव में, हम एक ऐसी प्रणाली को नकली करने जा रहे हैं जो स्टैक पर होनी चाहिए थी, लेकिन इससे पहले कि वह वास्तव में अपने कोड को निष्पादित करती है।

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



हम मानते थे कि जब आप फ़ंक्शन पास करते हैं तो कोई तर्क नहीं होता है, लेकिन अब यह थोड़ा अलग दिखता है। हमें केवल यह सुनिश्चित करने की आवश्यकता है कि हम जो ओवरफ़्लो कोड बना रहे हैं उसमें तर्क है। हमें बस यह सुनिश्चित करना है कि यह फर्जी कॉलिंग फ़्रेम इस सरणी में है। इस प्रकार, हमारा काम निम्नानुसार होगा। याद रखें कि स्टैक ओवरफ्लो नीचे से ऊपर तक जाता है।



सबसे पहले, हम यहां सिस्टम एड्रेस डालने जा रहे हैं। और शीर्ष पर हम कुछ जंक रिटर्न एड्रेस डालेंगे । यह वह जगह है जहां सिस्टम खत्म होने के बाद वापस आ जाएगा। यह पता बाइट्स का एक यादृच्छिक सेट होगा। इसके ऊपर हम एड्रेस bash_path डालेंगे । जब बफर ओवरफ्लो होता है तो क्या होता है?

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

अब हमने क्या किया है? हमने कॉलिंग कन्वेंशन , कॉलिंग कन्वेंशन के ज्ञान का लाभ उठाया, नकली स्टैक फ्रेम या नकली फ्रेम नाम बनाने के लिए एक मंच के रूप में, मैं कहूंगा। इन फर्जी कॉलिंग फ़्रेमों का उपयोग करके, हम किसी भी फ़ंक्शन को संदर्भित कर सकते हैं और जिसे पहले से ही एप्लिकेशन द्वारा परिभाषित किया गया है।

अगला सवाल हमें पूछना चाहिए: क्या होगा अगर प्रोग्राम में यह चार * bash_path लाइन बिल्कुल नहीं है ? मैं ध्यान देता हूं कि यह रेखा कार्यक्रम में लगभग हमेशा मौजूद रहती है। हालांकि, मान लीजिए कि हम एक उलटे दुनिया में रहते हैं, और यह अभी भी नहीं है। तो हम इस लाइन को एक कार्यक्रम में डालने के लिए क्या कर सकते हैं?

इसके लिए सबसे पहली बात आप bash_path के लिए सही पते को निर्दिष्ट कर सकते हैं, इसे उच्च स्तर पर रख सकते हैं, यहाँ हमारे ढेर के इस डिब्बे में, तीन तत्वों को सम्मिलित किया गया है, जिनमें से प्रत्येक का आकार 4 बाइट्स है:

/ ०
/ पैट
/ बिन



लेकिन किसी भी मामले में, हमारे सूचक यहां आते हैं और - बूम! - बात तो हो गई। इस तरह, अब आप उन्हें केवल अपने शेल कोड में रखकर तर्क कह सकते हैं। भयानक है, है ना? और यह सब पूर्ण बीआरपी हमले से पहले बनाया गया है। लेकिन इससे पहले कि आप एक पूर्ण BROP हमले को इंगित करें, आपको यह समझने की आवश्यकता है कि आप कोड के अंदर पहले से मौजूद चीजों को कैसे एक साथ जोड़ते हैं । जब मेरे पास यह डंप किया गया पता है, तो हम केवल शेल एक्सेस करना चाहते हैं। लेकिन अगर आप हमलावर हैं, तो आप इस रिटर्न एड्रेस, या रिटर्न एड्रेस को किसी ऐसी चीज के लिए निर्देशित कर सकते हैं, जिसका इस्तेमाल वास्तव में किया जा सके। और अगर आपने ऐसा किया है, तो आप एक पंक्ति में एक पंक्ति में कई फ़ंक्शन, एक पंक्ति में एक फ़ंक्शन के कई संकेत स्ट्रिंग कर सकते हैं। यह वास्तव में एक बहुत ही शक्तिशाली विकल्प है।

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

मान लीजिए हमारा लक्ष्य यह है कि हम सिस्टम को एक मनमाना संख्या कहना चाहते हैं। हम केवल एक बार ऐसा नहीं करना चाहते हैं, हम इसे कई बार मनमानी करेंगे। तो यह कैसे किया जा सकता है?

ऐसा करने के लिए, हम जानकारी के दो टुकड़ों का उपयोग करते हैं जो हम पहले से ही जानते हैं कि कैसे प्राप्त करें। हम जानते हैं कि सिस्टम का पता कैसे लगाया जाता है - आपको बस GDB पर गौर करने और इसे खोजने की आवश्यकता है। हम यह भी जानते हैं कि इस लाइन का पता कैसे लगाएं, बिन / बैश । अब, सिस्टम पर कई कॉल का उपयोग करके इस हमले को शुरू करने के लिए, हमें गैजेट्स का उपयोग करने की आवश्यकता है। यह हमें बीआरपी में होने वाली घटनाओं के करीब लाता है।

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



ये गैजेट मानक उपकरण हैं जो हैकर्स बाइनरी फाइलों जैसी चीजों को खोजने के लिए उपयोग करते हैं। इनमें से किसी एक गैजेट को ढूंढना भी आसान है, यह मानते हुए कि आपके पास बाइनरी की एक प्रति है, और हमने यादृच्छिकरण से परेशान नहीं किया है। ये चीजें खोजने में बहुत आसान हैं, साथ ही साथ सिस्टम का पता खोजने के लिए भी बहुत आसान हैं।

तो, अगर हमारे पास इनमें से एक गैजेट है, तो हम इसका उपयोग क्यों कर सकते हैं? बेशक, बुराई करने के लिए! ऐसा करने के लिए, आप निम्न कार्य कर सकते हैं।

मान लीजिए कि हम अपने स्टैक को बदलते हैं ताकि यह इस तरह दिखे, शोषण, जैसा कि पहले था, नीचे से ऊपर निर्देशित है। पहली चीज जो हम करते हैं वह सिस्टम एड्रेस को यहां रखा गया है, और इसके ऊपर हमने पॉप / रिट गैजेट का एड्रेस डाला है। इससे भी अधिक, हम bash_path का पता डालते हैं , और फिर सब कुछ दोहराते हैं: ऊपर से हम फिर से सिस्टम का पता, गैजेट पॉप / रिट का पता और bash_path का पता डालते हैं ।



अब यहाँ क्या होगा? यह थोड़ा जटिल होगा, इसलिए इस व्याख्यान के नोट्स इंटरनेट पर उपलब्ध हैं, और अब के लिए आप बस सुन सकते हैं कि यहां क्या हो रहा है, लेकिन जब मैंने पहली बार यह समझा, तो यह समझने जैसा था कि सांता क्लॉस मौजूद नहीं था!

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



यह स्पष्ट है कि हम इस क्रम से संबंधित चीजों की मनमानी करने के लिए संबंधित हो सकते हैं। अनिवार्य रूप से, कर्नेल को रिवर्स-ओरिएंटेड प्रोग्रामिंग कहा जाता है। कृपया ध्यान दें कि हमने इस स्टैक पर कुछ भी प्रदर्शन नहीं किया है। हमने कुछ भी नष्ट किए बिना डेटा के निष्पादन को रोकने की अनुमति दी। हमने बस एक अप्रत्याशित छलांग लगाई जो हम चाहते हैं। वास्तव में यह बहुत, बहुत, बहुत, स्मार्ट है।

और जो दिलचस्प है वह यह है कि उच्च स्तर पर हमने कंप्यूटिंग के लिए इस नए मॉडल की पहचान की है। , , , . , , . , - . , , . , . . , . , , stack canaries.

, «» , . , , «» ret address saved %ebp , - , «». , ret , , «», , - . stack canaries .

, «». , . , «»?

, , , .
, , , «» , «» «».

, , , «» , , .
, - , «» , . , ? ?
, fork . , fork . , , , fork , , , , «» . , stack canaries .

«»? . , , , «». «» . .



, , – , «». , , 0. , «», . , :

«, «»! , 0. «»! 1 – «», 2 – . , 2- . , , «».



, , , .

«», , , . , , «».

57:10

:

एमआईटी पाठ्यक्रम "कंप्यूटर सिस्टम सुरक्षा"। 3: « : », 3


.

हमारे साथ बने रहने के लिए धन्यवाद। क्या आप हमारे लेख पसंद करते हैं? अधिक दिलचस्प सामग्री देखना चाहते हैं? एक आदेश रखकर या अपने दोस्तों को इसकी अनुशंसा करके हमें समर्थन दें, एंट्री-लेवल सर्वरों के अनूठे एनालॉग पर हैबर उपयोगकर्ताओं के लिए 30% छूट जो हमने आपके लिए ईजाद की है: VPS (KVM) E5-2650 v4 (6 कोर) 10GB DDR4 240GB SSD 1Gbps से पूरा सच $ 20 या सर्वर को कैसे विभाजित करें? (विकल्प RAID1 और RAID10 के साथ उपलब्ध हैं, 24 कोर तक और 40GB DDR4 तक)।

डेल R730xd 2 बार सस्ता? केवल हमारे पास 2 x Intel Dodeca-Core Xeon E5-2650v4 128GB DDR4 6x480GB SSD 1Gbps 100 टीवी 249 डॉलर में नीदरलैंड और यूएसए से है! इन्फ्रास्ट्रक्चर Bldg का निर्माण कैसे करें के बारे में पढ़ें । एक पैसा के लिए 9,000 यूरो की लागत डेल R730xd E5-2650 v4 सर्वर का उपयोग कर वर्ग?