एमआईटी पाठ्यक्रम "कंप्यूटर सिस्टम सुरक्षा"। व्याख्यान 2: "हैकर हमलों का नियंत्रण", भाग 2

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

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

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

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



श्रोता: यह "कैनरी" को क्यों प्रभावित करेगा?

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

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

श्रोता: क्या कोई हमलावर रिटर्न एड्रेस को फिर से लिख सकता है और "कैनरी" बदल सकता है? वह कैसे सत्यापित कर सकता है कि इसे संशोधित किया गया है, लेकिन अपने कार्य को पूरा करने के लिए जारी है।

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

श्रोता: एक हमलावर को पता नहीं चल सकता है या अनुमान लगा सकता है कि "कैनरी" का क्या अर्थ है?

प्रोफेसर: यह वही है जिसके बारे में मैं बात करने जा रहा हूँ! इस सर्किट में क्या समस्या है? क्या होगा यदि, उदाहरण के लिए, हम प्रत्येक प्रोग्राम में मान A डालते हैं? या A के 4 मानों की पूरी शाखा? बेशक, कोई भी हैकर बफर के आकार, उसकी क्षमता का पता लगा सकता है, और इस तरह किसी भी प्रणाली में "कैनरी" की स्थिति निर्धारित कर सकता है। इसलिए, हम विभिन्न प्रकार की मात्राओं का उपयोग कर सकते हैं जो हम इसे रोकने के लिए अपने "कैनरी" में डालते हैं।

एक चीज है जो आप हमारे "कैनरी" के साथ कर सकते हैं। यह एक बहुत ही मजेदार प्रकार का "कैनरी" होगा, जो सी प्रोग्राम फ़ंक्शंस का उपयोग करता है और विशेष वर्णों को संसाधित करता है, तथाकथित "कैनरी" का निर्धारक प्रकार।



कल्पना कीजिए कि आपने "कैनरी" के लिए वर्ण 0 का उपयोग किया है। शून्य का बाइनरी मान शून्य बाइट है, ASCII में शून्य वर्ण है। -1 के मान का अर्थ है पिछली स्थिति में वापसी और इसी तरह। जब वे वर्ण या मान 0, CR, LF, -1 से मुठभेड़ करते हैं, तो कई कार्य रुक जाते हैं या ऑपरेशन को बदल देते हैं। कल्पना कीजिए कि आप एक हैकर के रूप में बफर पर जाने के लिए कुछ स्ट्रिंग प्रबंधन फ़ंक्शन का उपयोग करते हैं, "कैनरी" में वर्ण 0 का सामना करते हैं और प्रक्रिया रुक जाती है! यदि आप "कैरिज रिटर्न" -1 फ़ंक्शन का उपयोग करते हैं, जिसे अक्सर लाइन टर्मिनेटर के रूप में उपयोग किया जाता है, तो प्रक्रिया भी बंद हो जाएगी। तो -1 एक और जादुई संकेत है।

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



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

प्रोफेसर: मैं आपके प्रश्न को समझता हूं - आपका मतलब है कि हम एक नियतात्मक "कैनरी" का उपयोग करते हैं, लेकिन मानक पुस्तकालय के कार्यों में से एक का उपयोग नहीं करते हैं जो हमारे पात्रों 0, सीआर, एलएफ, -1 द्वारा "धोखा" हो सकता है। फिर हां, जिस स्थिति का आपने वर्णन किया है, "कैनरी" की जरूरत नहीं है।

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

श्रोता: क्या यह संभव है कि कुछ सेकंड या मिलीसेकंड की संख्या को यादृच्छिक संख्या के रूप में उपयोग करें और उन्हें "कैनरी" में उपयोग करें?

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

श्रोता: भले ही हम बफर अतिप्रवाह की शुरुआत के बारे में लॉग को देखने का प्रबंधन करते हैं, यह अभी भी महत्वपूर्ण है कि हम अनुरोध को किस समय मना कर दें। और अगर हम सर्वर पर कंप्यूटर के अनुरोध को कितनी देर तक नियंत्रित कर सकते हैं, तो यह संदेह नहीं है कि सटीक समय का अनुमान लगाया जा सकता है।

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

श्रोता: रिकॉर्ड के लिए, अपनी खुद की यादृच्छिकता पर पर्दा डालने की कोशिश करना एक बुरा विचार है?

प्रोफेसर: बिलकुल सही!

श्रोता: यानी, आमतौर पर हमें सिर्फ उन सभी चीज़ों का उपयोग करना होता है जो हमारे सिस्टम का समर्थन करते हैं, है ना?

प्रोफेसर: हाँ, यह सच है। यह हमारे अपने क्रिप्टोकरेंसी के आविष्कार की तरह है, जो एक और लोकप्रिय चीज है जो हमारे स्नातक कभी-कभी करना चाहते हैं। लेकिन हम एनएसए नहीं हैं, हम गणितज्ञ नहीं हैं, इसलिए यह आमतौर पर विफल रहता है। तो आप इसके बारे में बिल्कुल सही हैं।

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

ऐसा ही एक तरीका है फंक्शन पॉइंटर्स को फिर से लिखना। क्योंकि अगर फंक्शन पॉइंटर पर झटका लगता है, तो "कैनरी" कुछ नहीं कर सकता है।

मान लीजिए कि आपके पास फॉर्म का एक कोड है int * ptr ... .. , जो पॉइंटर पॉइंटर है, इससे कोई फर्क नहीं पड़ता कि कैसे, फिर आपके पास char buf बफर [128] , हो जाता है (buf) फ़ंक्शन, और बहुत नीचे एक पॉइंटर जो कुछ मान असाइन किया गया है : * पीटीआर = 5 ।

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



श्रोता: क्या सूचक बफर के नीचे स्थित हो सकता है?

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

श्रोता: आप "कैनरी" को "कैनरी" फ़ंक्शन से क्यों नहीं जोड़ सकते, जैसा कि आपने रिटर्न एड्रेस से किया है?

प्रोफेसर: यह एक दिलचस्प क्षण है! आप ऐसे काम कर सकते हैं। वास्तव में, आप एक संकलक की कल्पना करने की कोशिश कर सकते हैं कि जब भी इसका कोई संकेतक होता है, तो यह हमेशा कुछ चीजों के लिए एक ऐड-ऑन जोड़ने की कोशिश करता है। हालाँकि, इन सभी चीजों की जाँच करना बहुत महंगा होगा। क्योंकि हर बार जब आप किसी सूचक का उपयोग करना चाहते हैं या किसी फ़ंक्शन को कॉल करना चाहते हैं, तो आपके पास एक कोड होना चाहिए जो यह जांच करेगा कि क्या यह "कैनरी" सही है। मूल रूप से, आप कुछ ऐसा ही कर सकते थे, लेकिन क्या इसका कोई मतलब है? हम देखते हैं कि "कैनरी" इस स्थिति में मदद नहीं करता है।

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



श्रोता: तो कैनरी में रिटर्न एड्रेस की तुलना में कम बिट्स होते हैं? क्योंकि अन्यथा आप केवल इस पते को याद नहीं रख सकते हैं और जांच सकते हैं कि क्या यह बदल गया है?

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



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

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

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



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

मान लीजिए कि p और q दोनों की मेमोरी लाइनें मेमोरी स्पेस में एक दूसरे के बगल में स्थित हैं। इस मामले में, बुरी चीजें हो सकती हैं, है ना? क्योंकि strcpy फ़ंक्शन का उपयोग str2 की सामग्री को str1 में कॉपी करने के लिए किया जाता है। Str2 शून्य के साथ समाप्त होने वाली स्ट्रिंग के लिए एक सूचक होना चाहिए, और strcpy str1 के लिए एक संकेतक लौटाता है। यदि str1 और str2 लाइनें ओवरलैप होती हैं, तो strcpy फ़ंक्शन का व्यवहार अपरिभाषित होता है।

इसलिए, स्मृति p को संसाधित करने वाला strycpy फ़ंक्शन एक ही समय में q के लिए आवंटित स्मृति को प्रभावित कर सकता है। और यही समस्या पैदा कर सकता है।

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

कल्पना करें कि स्वतंत्र और मॉलोक कार्यों के कार्यान्वयन के अंदर, हाइलाइट किया गया ब्लॉक इस तरह दिखता है।

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



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

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



यही है, निष्पादन के कुछ बिंदु पर, नि: शुल्क कार्यों को आकार के आधार पर एक निश्चित सूचक प्राप्त होने जा रहा है: p = get.free.block (आकार) , और आकार वह है जो हमलावर को नियंत्रित करता है, क्योंकि वह एक बफर अतिप्रवाह करता है, सही ढंग से ?

उन्होंने अंकगणितीय गणनाओं का एक गुच्छा किया, इस ब्लॉक के पीछे के कार्य और बिंदुओं को देखा और अब "बैक" और "फॉरवर्ड" पॉइंटर्स को अपडेट करने जैसा कुछ करने जा रहे हैं - ये नीचे की दो पंक्तियाँ हैं।



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

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

लेकिन अगर हम आकार को नियंत्रित करते हैं, तो इसका मतलब है कि हम पूरी प्रक्रिया को ऊपर की चार लाइनों से नियंत्रित करते हैं। इसका मतलब यह है कि यदि हम समझते हैं कि अतिप्रवाह कैसे काम करता है, तो हम मेमोरी को डेटा चुन सकते हैं जिस तरह से हम चुनते हैं। जैसा कि मैंने कहा, ऐसी चीजें अक्सर आपके अपने कोड के साथ होती हैं, यदि आप एक पॉइंटर के साथ स्मार्ट नहीं हैं। जब आप फ्री q और फ्री p या कुछ और जैसे कुछ डबल फ्री एरर बनाते हैं, तो आपका फंक्शन क्रैश हो जाता है। क्योंकि आपने मेटाडेटा के साथ गड़बड़ की है जो इन चयनित ब्लॉकों में से प्रत्येक में रहते हैं, और कुछ बिंदु पर यह गणना कुछ प्रकार के "कचरा" मूल्य का संकेत देगी, जिसके बाद आप "मृत" हो जाएंगे। लेकिन अगर आप हमलावर हैं, तो आप इस मूल्य को चुन सकते हैं और अपने लाभ के लिए इसका इस्तेमाल कर सकते हैं।

चलो बफर अतिप्रवाह हमलों को रोकने के लिए एक और दृष्टिकोण पर चलते हैं। यह दृष्टिकोण सीमाओं की जांच करना है। सीमा जाँच का उद्देश्य यह सुनिश्चित करना है कि जब आप एक विशिष्ट पॉइंटर का उपयोग करते हैं, तो यह केवल यह संदर्भित करेगा कि मेमोरी ऑब्जेक्ट क्या है। और यह पॉइंटर इस मेमोरी ऑब्जेक्ट के स्वीकार्य सीमा के भीतर है। यह सत्यापन का मुख्य विचार है। — . , C, . , : , , ?

, – . 1024 , : char [1024] , char *y = & [108].



? ? कहना कठिन है। , , . , , - .
- , , , . . , , , . , , . , , .

, , struct union . , . : integer , struct , int .

, union , . , integer , struct , .

, , - : int p: & (u,s,k) , : u, s, k.



, , , , . , , union integer , struct . , , , . .

p' , p , p' , .



, , . , , union . , - - union , , , . , , X. , , , , . , , . .

, . , p p' , . .

? Electric fencing – . , , , , .



, - , . , , . , . , , , .

- C C++, , , . - , , - . , . , «» — , , , . , , .

, guard page – ! , .

59:00

:

MIT « ». 2: « », 2


पाठ्यक्रम का पूरा संस्करण यहां उपलब्ध है ।

, . ? ? , 30% entry-level , : VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps $20 ? ( RAID1 RAID10, 24 40GB DDR4).

Dell R730xd 2 ? 2 Intel Dodeca-Core Xeon E5-2650v4 128GB DDR4 6x480GB SSD 1Gbps 100 $249 ! . c Dell R730xd 5-2650 v4 9000 ?