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

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

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

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

बफर ओवरफ्लो के लिए कारनामों पर व्याख्यान में आपका स्वागत है। आज हम बैगी सीमा की चर्चा को समाप्त करेंगे और फिर अन्य बफर अतिप्रवाह संरक्षण विधियों की ओर बढ़ेंगे।



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

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

मान लीजिए कि हम एक पॉइंटर पी असाइन करने जा रहे हैं और इसके लिए 44 बाइट्स का आकार आवंटित करते हैं। यह भी मान लें कि स्लॉट का आकार 16 बाइट्स है।

जब हम मॉलोक फ़ंक्शन असाइन करते हैं तो क्या होता है? आप पहले से ही जानते हैं कि इस मामले में Baggy सीमा प्रणाली इस वितरण को 2n लघुगणक के साथ पूरक करने का प्रयास करेगी। तो हमारे 44 बाइट्स के पॉइंटर के लिए, 64 बाइट्स की मेमोरी आवंटित की जाएगी। लेकिन स्लॉट का आकार 16 बाइट्स है, इसलिए हम प्रत्येक 16 बाइट्स के 64/16 = 4 सीमा तालिकाओं का निर्माण करेंगे। इनमें से प्रत्येक प्रविष्टि को आकार वितरण लॉग में रखा जाएगा।

इसके बाद, एक और पॉइंटर चार * q = p + 60 असाइन करें। हम देखते हैं कि यह मान सीमा से बाहर है क्योंकि पी का आकार 44 बाइट्स है, और यहां यह 60 बाइट्स है। लेकिन Baggy सीमाएं काम करती हैं ताकि इस मामले में कुछ भी बुरा न हो, हालांकि प्रोग्रामर को ऐसा नहीं करना चाहिए था।

अब मान लेते हैं कि हम जो अगला काम करते हैं, वह एक और पॉइंटर प्रदान करता है, जो कि char * r = q + 16 के बराबर होगा। अब यह वास्तव में एक त्रुटि का कारण होगा, क्योंकि ऑफसेट आकार 60 + 16 = 76 होगा, जो कि 4 स्लॉट्स (4x16 = 64 बाइट्स) से 12 बाइट्स बड़ा है जिसे बग्गी बाउंड्स सिस्टम आवंटित किया गया है । और यह अतिरिक्त वास्तव में आधे से अधिक स्लॉट है।



यदि आपको याद है, तो इस मामले में Baggy सीमा प्रणाली तुरंत एक महत्वपूर्ण सिंक्रनाइज़ेशन त्रुटि का जवाब देगी, जिससे प्रोग्राम क्रैश हो जाएगा और वास्तव में इसे रोक देगा।

तो आइए कल्पना करें कि हमारे पास केवल दो लाइनें हैं:

चार * पी = मालॉक (44)
char * q = p + 60

और कोड के साथ कोई तीसरी पंक्ति नहीं है। इसके बजाय, हम यह करेंगे:

char * s = q + 8

इस स्थिति में, सूचक का मान 60 + 8 = 68 बिट्स होगा, जो कि बग्गी सीमा द्वारा निर्दिष्ट सीमाओं से 4 बाइट अधिक होगा। वास्तव में, यह एक महत्वपूर्ण त्रुटि का कारण नहीं होगा, हालांकि मूल्य सीमाओं से परे जाता है। हमने यहां क्या किया, पॉइंटर के लिए एक उच्च क्रम बिट सेट किया गया है। इसलिए यदि कोई बाद में उसे रोकने की कोशिश करता है, तो इस बिंदु पर एक महत्वपूर्ण त्रुटि होगी।



और आखिरी चीज जो हम करेंगे वह है एक और पॉइंटर असाइन करना:

char * t = s - 32

वास्तव में, हमने ऐसा किया - हमने सूचक को सीमा पर लौटा दिया। इसलिए अगर शुरू में यह परे चला गया है, तो अब हमने इसे मूल रूप से आवंटित मात्रा में लौटा दिया है जो हमने सूचक के लिए बनाया था। इसलिए, अब t इसकी संरचना में एक उच्च-क्रम बिट नहीं होगा, और इसे आसानी से dereferenced जा सकता है।



श्रोता: प्रोग्राम को कैसे पता चलता है कि r में आधे से अधिक स्टैक है?

प्रोफेसर मिकेंस: ध्यान दें कि जब हमने आर बनाया था, तो हमें एक टूल कोड मिला था जो पॉइंटर्स के साथ इन सभी ऑपरेशनों में काम करेगा। तो हम बता सकते हैं कि q कहां स्थित होगा, और हम जानते हैं कि यह बग्गी सीमा के भीतर है। इसलिए, जब हम यह ऑपरेशन q + 16 करते हैं , तो Baggy सीमा के उपकरण जानते हैं कि यह प्रारंभिक मूल्य कहां से आया है। और फिर, यदि इस मूल आकार की एक ऑफसेट होती है , तो बैगी सीमा आसानी से निर्धारित करेगी कि ऑफसेट स्लॉट आकार के offset से बड़ा है।

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

आशा है कि यह समझ में आएगा। यह होमवर्क का बहुत संक्षिप्त अवलोकन था, लेकिन मुझे आशा है कि आप इसे आसानी से समझ सकते हैं।

तो, हमारे पास एक संकेतक है जो इस तरह दिखता है:

char * p = malloc (256) है , तो हम पॉइंटर चार * q = p + 256 जोड़ते हैं, जिसके बाद हम इस पॉइंटर को डिरेल करने की कोशिश करेंगे।

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



इन 2 उदाहरणों से, आप समझ सकते हैं कि बैगी सीमा प्रणाली कैसे काम करती है । जैसा कि मैंने पिछले व्याख्यान में उल्लेख किया है, आपको वास्तव में प्रत्येक पॉइंटर ऑपरेशन को करने की आवश्यकता नहीं है यदि आप यह पता लगाने के लिए स्थैतिक कोड विश्लेषण का उपयोग कर सकते हैं कि पॉइंटर ऑपरेशन का एक विशिष्ट सेट सुरक्षित है। मैं कुछ स्थैतिक विश्लेषणों की आगे की चर्चा को स्थगित कर दूंगा, लेकिन यह कहने के लिए पर्याप्त है कि आपको हमेशा इन गणितीय क्रियाओं को करने की आवश्यकता नहीं है, हम पहले भी यह जाँच चुके हैं।

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

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

हालांकि, टूल कोड चलाते समय, यह वास्तव में टेबल की इस पंक्ति के लिए उपयुक्त मान सेट करने के लिए Baggy सीमा एल्गोरिथ्म का उपयोग करेगा।



जब कोई पॉइंटर मेमोरी स्पेस के ऊपर से आता है, तो यह हमेशा अधिकतम संभव 2n + 31 सीमा पर सेट होता है। इसका मतलब यह है कि बग्गी सीमाएं कभी नहीं मानेंगी कि एक गैर-टूल लाइब्रेरी से "आने वाला" एक पॉइंटर ऑपरेशन सीमा से परे जा सकता है।

विचार यह है कि टूल कोड में, हम हमेशा पॉइंटर्स के लिए इन तुलनाओं को निष्पादित करेंगे, लेकिन यदि हम फॉर्म 2n + 31 के गैर-टूल कोड के लिए पॉइंटर राइटिंग की सीमाएं निर्धारित करते हैं, तो हमारे पास कभी भी एक डिफरेंस एरर नहीं होगा। यही है, हमारे पास बैगी सीमा कोड प्रविष्टियों और पिछले पुस्तकालयों के गैर-वाद्य रिकॉर्ड के बीच एक अच्छी बातचीत है।

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

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

श्रोता: अगर हमारे पास मेमोरी को आवंटित करने के लिए टूल कोड है, तो क्या यह उसी मॉलोक फ़ंक्शन का उपयोग करता है जो विशेषता कोड का उपयोग करता है?

प्रोफेसर: यह थोड़ा नाजुक सवाल है। यदि हम यहां मामले पर विचार करते हैं, तो यह कड़ाई से मनाया जाता है, क्योंकि हमारे पास स्मृति के दो क्षेत्र हैं, जिनमें से प्रत्येक इसके लिए स्थापित नियमों का पालन करता है। लेकिन सिद्धांत रूप में, यह उस कोड पर निर्भर करेगा जो चयनित प्रोग्रामिंग भाषा का उपयोग करता है। कल्पना करें कि C ++ में, उदाहरण के लिए, आप अपना स्वयं का क्वालीफायर असाइन कर सकते हैं। तो यह कोड के कुछ विवरणों पर निर्भर करता है।

श्रोता: अगर ३१ बिट्स की सीमा निर्धारित है या नहीं, तो क्वालीफ़ायर कैसे जाँच सकता है?

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

तो, सब कुछ है कि हम ऊपर 32-बिट सिस्टम में Baggy सीमा के संचालन से संबंधित जांच की। विचार करें कि 64-बिट सिस्टम का उपयोग करते समय क्या होता है। ऐसी प्रणालियों में, आप वास्तव में सीमा तालिका से छुटकारा पा सकते हैं, क्योंकि हम संकेतक में ही सीमाओं के बारे में कुछ जानकारी संग्रहीत कर सकते हैं।

विचार करें कि बग्गी सीमा में एक नियमित सूचक कैसा दिखता है। इसमें 3 भाग होते हैं। 21 बिट्स को पहले, शून्य भाग के लिए आवंटित किया जाता है, आकार के लिए एक और 5 बिट्स आवंटित किए जाते हैं, यह लॉग का मुख्य आकार है, और अन्य 38 सामान्य पते के बिट्स हैं।



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

क्या होता है जब हमारे पास इनमें से केवल एक बिंदु होता है? खैर, 32-बिट सिस्टम पर, हम जो कुछ भी कर सकते हैं वह सिर्फ एक उच्च क्रम बिट सेट है और उम्मीद है कि यह चीज़ स्लॉट के आधे से अधिक आकार कभी नहीं मिलेगी। लेकिन अब जब हमारे पास यह सब अतिरिक्त पता है, तो आप इस ओईटर में सीधे ओओबी (बाध्य से बाहर) सीमाओं के बाहर ऑफसेट रख सकते हैं। तो हम आकृति में दिखाए गए एक जैसे कुछ कर सकते हैं, सूचक को 4 भागों में विभाजित करते हैं और इसके आकार को फिर से विभाजित करते हैं।

इस प्रकार, हम ऑफसेट सीमाओं के लिए 13 बिट्स प्राप्त कर सकते हैं, अर्थात, यह लिखिए कि यह ओओबी पॉइंटर कितना दूर होगा जहां से यह होना चाहिए। फिर फिर से, आप यहां बताई गई वस्तु का वास्तविक आकार 5 सेट कर सकते हैं, और शेष शून्य भाग, जो अब 21-13 = 8 बिट्स होगा। और फिर 38 बिट्स के हमारे पता भाग का अनुसरण करता है। इस उदाहरण में, आप 64-बिट सिस्टम का उपयोग करने के फायदे देखते हैं।



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

श्रोता: दूसरे मामले में ऑफ़सेट आकार के सामने क्यों स्थित है, और पिछले मामले में नहीं है, और ऑफ़सेट आकार बड़ा होने पर क्या होगा?

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

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

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

तो, बग्गी सीमा का उपयोग करने की कीमत क्या है? वास्तव में, हमारे पास इस कीमत के केवल 4 घटक हैं।



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

इसके अलावा, आपने सीपीयू पर लोड भी बढ़ा दिया, जो पॉइंटर्स के साथ इन सभी इंस्ट्रूमेंटल ऑपरेशंस को करने के लिए मजबूर है। चूंकि प्रत्येक या लगभग हर सूचक के लिए एक ही ऑपरेटिंग मोड का उपयोग करके सीमाओं की जांच करना आवश्यक है, जो आपके प्रोग्राम के निष्पादन को धीमा कर देगा।

झूठे अलार्म के साथ एक समस्या भी है। हम पहले से ही चर्चा कर चुके हैं कि ऐसा क्या हो सकता है कि एक कार्यक्रम ऐसे बिंदुओं को उत्पन्न करता है जो सीमाओं से परे जाते हैं, लेकिन कभी भी उन्हें रोकने की कोशिश नहीं करते हैं। सख्ती से बोलना, यह कोई समस्या नहीं है। यदि वे स्लॉट आकार के 1/2 से परे, कम से कम 32-बिट समाधान में जाते हैं, तो बैगी सीमाएं इन " सीमा से बाहर" झंडे को ध्वजांकित करेंगी।

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

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

तो, Baggy सीमा प्रणाली का उपयोग करने के लिए हमें एक कीमत चुकानी होगी, जिसमें अंतरिक्ष का अत्यधिक उपयोग, CPU लोड में वृद्धि, झूठे अलार्म और एक संकलक का उपयोग करने की आवश्यकता शामिल है।

यह बग्गी सीमा की चर्चा को समाप्त करता है ।

अब हम दो अन्य बफर अतिप्रवाह शमन रणनीतियों के बारे में सोच सकते हैं। वास्तव में, उन्हें समझाने और समझने में बहुत आसान है।

इनमें से एक दृष्टिकोण को गैर-निष्पादन योग्य मेमोरी कहा जाता है। उनका मुख्य विचार यह है कि स्वैप हार्डवेयर R , W, और X के 3 बिट्स को इंगित करेगा - स्मृति में आपके पास मौजूद प्रत्येक पृष्ठ के लिए - पढ़ना, लिखना और निष्पादित करना। , , . 2 , , , , .

, . , , , , - . , . « W X » , , , , , . , , . . , , . ?

- , . , . , , .

, , , , . , , . .

, . – just-in-time , .

-, JavaScript . JavaScript, , - - «» , - «» , x86 . , .
. , , just-in-time W , X . , , .

— . , , , .



, , . GDB, , . , . , . .

, . , , , , , .

: , , — . , , , , , , , - . , , .

, , , GDB , , , , . .
, , , , . - , - , . , . , , .

, ? , . , , . , , , , - , .

27:10

:

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


.

हमारे साथ बने रहने के लिए धन्यवाद। क्या आप हमारे लेख पसंद करते हैं? अधिक दिलचस्प सामग्री देखना चाहते हैं? एक आदेश रखकर या अपने दोस्तों को इसकी अनुशंसा करके हमें समर्थन दें, एंट्री-लेवल सर्वरों के अनूठे एनालॉग पर हैबर उपयोगकर्ताओं के लिए 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 सर्वर का उपयोग कर वर्ग?