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

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

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

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

क्या आप मुझे बता सकते हैं कि सुरक्षा दृष्टिकोण की कमी क्या है जो गार्ड पृष्ठ का उपयोग करता है?

श्रोता: ज्यादा समय लगता है!

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

श्रोता: गार्ड पेज इतना बड़ा क्यों होना चाहिए?

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



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

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



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

कल्पना करें कि मेरे पास यह कोड है: int * ptr = malloc (8) , यह एक संकेतक है जिसके लिए 8 बाइट्स आवंटित किए जाते हैं। अगला, मेरे पास कुछ लूप है जो पॉइंटर के लिए कुछ मान असाइन करने वाला है और फिर ptr ++ पॉइंटर इन्क्रीमेंट निम्नानुसार है। हर बार जब इस कोड को कर्व एड्रेस पॉइंटर के वर्तमान पते पर निष्पादित किया जाता है, तो यह जांचता है कि पॉइंटर पहले और दूसरे भाग में निर्दिष्ट सीमाओं के भीतर है या नहीं।

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



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

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

इसलिए, सी कोड में एक बहुत लोकप्रिय चीज एक संरचना के आकार को कुछ लेना है, और फिर इस आकार के आधार पर कुछ करना है - इस आकार की संरचनाओं के लिए आरक्षित डिस्क स्थान, और इसी तरह।

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

और अब हम छाया डेटा की संरचना के संबंध में सीमाओं की जाँच करने के बारे में बात करेंगे। संरचना का मुख्य विचार यह है कि आप जानते हैं कि आपके द्वारा रखी जाने वाली प्रत्येक वस्तु कितनी बड़ी है, अर्थात आप उस आकार को जानते हैं जिसे आपको इस वस्तु के लिए आरक्षित करने की आवश्यकता है। इसलिए, उदाहरण के लिए, यदि आपके पास एक पॉइंटर है जिसे आप मॉलोक फ़ंक्शन के साथ कहते हैं, तो आपको ऑब्जेक्ट का आकार निर्दिष्ट करने की आवश्यकता है: char xp = malloc (आकार) ।



यदि आपके पास इस चर पी [256] की तरह एक स्थिर चर है, तो संकलक स्वचालित रूप से यह पता लगा सकता है कि इसके स्थान के लिए सीमाएं क्या होनी चाहिए।

इसलिए, इन बिंदुओं में से प्रत्येक के लिए, आपको किसी तरह दो ऑपरेशन सम्मिलित करने की आवश्यकता है। यह मुख्य रूप से अंकगणित है, जैसे कि q = p + 7 , या ऐसा ही कुछ। यह सम्मिलन deref * q = 'q' प्रकार के लिंक को dereferencing द्वारा किया जाता है। आपको आश्चर्य हो सकता है कि पेस्ट करते समय आप लिंक पर भरोसा क्यों नहीं कर सकते? हमें इन अंकगणित को करने की आवश्यकता क्यों है? तथ्य यह है कि सी और सी ++ का उपयोग करते समय, आपके पास दाईं ओर ऑब्जेक्ट के वैध अंत तक एक पास की ओर इशारा करते हुए सूचक होता है, जिसके बाद आप इसे स्टॉप कंडीशन के रूप में उपयोग करते हैं। तो, आप ऑब्जेक्ट पर जाते हैं और जैसे ही आप इस अनुगामी सूचक तक पहुंचते हैं, आप वास्तव में लूप को रोक देते हैं या ऑपरेशन को रोक देते हैं।

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

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

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

मान लीजिए कि टाइप का एक अनुरोध = मॉलॉक (28) आ गया, यानी, 28 बाइट्स आवंटित करने के लिए एक अनुरोध। हमारे पास 128 बाइट ब्लॉक है जो इस अनुरोध के लिए आवंटित करने के लिए बहुत बेकार है। इसलिए, हमारे ब्लॉक को 64 बाइट्स के दो ब्लॉक में विभाजित किया गया है - 0 से 64 बाइट्स और 64 बाइट्स से 128 बाइट्स तक। और यह आकार हमारे अनुरोध के लिए भी बड़ा है, इसलिए दोस्त फिर से 64 बाइट्स के एक ब्लॉक को 2 भागों में विभाजित करता है और 32 बाइट्स के 2 ब्लॉक प्राप्त करता है।



कम असंभव है, क्योंकि 28 बाइट्स फिट नहीं होंगे, और 32 सबसे उपयुक्त न्यूनतम आकार है। तो अब यह 32-बाइट ब्लॉक हमारे पते पर आवंटित किया जाएगा a। मान लीजिए कि हमारे पास b = malloc (50) के लिए एक और क्वेरी है। बड्डी चयनित ब्लॉकों की जांच करता है, और चूंकि 50 64 के आधे से अधिक है, लेकिन 64 से कम है, मान को सबसे सही ब्लॉक में रखता है।

अंत में, हमारे पास 20 बाइट्स के लिए एक और अनुरोध है: c = malloc (20) , यह मान मध्य ब्लॉक में रखा गया है।



बडी के पास एक दिलचस्प संपत्ति है: जब आप किसी ब्लॉक में मेमोरी फ्री करते हैं और उसके बगल में एक ही आकार का एक ब्लॉक होता है, तो दोनों ब्लॉक को खाली करने के बाद, दोस्त दो खाली पड़ोसी ब्लॉकों को एक में मिला देता है।



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

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

तो बुग्गी बाउंस चेकिंग (बीबीसी) सिस्टम क्या करता है?



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

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

यह मेमोरी आवंटन के लिए एक काफी किफायती दृष्टिकोण है, क्योंकि बाइट्स की न्यूनतम संख्या का उपयोग किया जाता है, लेकिन यह 2 के कई होना चाहिए, अर्थात, आपके पास 16 या 32 नहीं, बल्कि 33 बाइट्स हो सकते हैं। इसके अलावा, बग्गी बाउंस चेकिंग आपको एक रेखीय सरणी (प्रति रिकॉर्ड 1 बाइट) में सीमा मूल्यों के बारे में जानकारी संग्रहीत करने की अनुमति देता है और आपको 16 बाइट्स के आकार के साथ 1 स्लॉट में मेमोरी आवंटित करने की अनुमति देता है। स्लॉट ग्रैन्युलैरिटी के साथ मेमोरी आवंटित करें। इसका क्या मतलब है?



यदि हमारे पास एक 16-बाइट स्लॉट है जहां हम मूल्य p = malloc (16) डालने जा रहे हैं, तो तालिका में मान तालिका [p / slot.size] = 4 की तरह दिखाई देगा ।



मान लीजिए कि अब हमें आकार p = malloc (32) में 32 बाइट्स का मान रखने की आवश्यकता है। हमें नए आकार से मेल खाने के लिए बॉर्डर टेबल को अपडेट करना होगा। और यह दो बार किया जाता है: पहली तालिका के रूप में [p / slot.size] = 5 , और फिर तालिका के रूप में [(p / slot.size) + 1] = 5 - पहली बार पहला स्लॉट, जो इस मेमोरी के लिए आवंटित किया गया है, और दूसरा समय - दूसरे स्लॉट के लिए। इस प्रकार हम 32 बाइट्स की मेमोरी आवंटित करते हैं। यह आकार वितरण लॉग जैसा दिखता है। इस प्रकार, दो मेमोरी आवंटन स्लॉट के लिए, सीमा तालिका दो बार अपडेट की जाती है। क्या यह स्पष्ट है? यह उदाहरण उन लोगों के लिए है जो संदेह करते हैं कि लॉग और टेबल का कोई अर्थ है या नहीं। क्योंकि हर बार मेमोरी आवंटन होने पर तालिकाओं को गुणा किया जाता है।

आइए देखें कि बॉर्डर टेबल के साथ क्या होता है। मान लीजिए कि हमारे पास एक कोड C है जो इस तरह दिखता है: p '= p + i , अर्थात, सूचक p' कुछ चर i को जोड़कर p से प्राप्त किया जाता है । तो हम पी के लिए आवंटित स्मृति आकार कैसे प्राप्त करें? ऐसा करने के लिए, आप निम्न तार्किक स्थितियों का उपयोग करते हुए तालिका को देखते हैं:

आकार = 1 << तालिका [पी >> स्लॉट_साइज का लॉग]



दाईं ओर हमारे पास p के लिए आवंटित डेटा का आकार है, जो 1. होना चाहिए। फिर आप इसे बाईं ओर ले जाएं और तालिका को देखें, इस सूचक आकार को लें, फिर दाईं ओर ले जाएं, जहां स्लॉट आकार तालिका का लॉग स्थित है। यदि अंकगणित काम करता है, तो हम पॉइंटर को सही ढंग से बॉर्डर टेबल पर बांधते हैं। यही है, सूचक का आकार 1 से अधिक होना चाहिए, लेकिन स्लॉट के आकार से छोटा। बाईं ओर हमारे पास मूल्य है, और दाईं ओर - स्लॉट का आकार, और सूचक मूल्य उनके बीच स्थित है।

मान लीजिए कि सूचक का आकार 32 बाइट्स है, तो तालिका में, कोष्ठक के अंदर, हमारे पास संख्या 5 होगी।

मान लीजिए कि हम इस सूचक का आधार कीवर्ड खोजना चाहते हैं: आधार = p & n (आकार - 1) । हम जो करने जा रहे हैं वह हमें एक निश्चित द्रव्यमान देता है, और यह द्रव्यमान हमें यहां स्थित आधार को पुनर्स्थापित करने की अनुमति देगा। कल्पना कीजिए कि हमारा आकार 16 है, बाइनरी में यह 16 = ... 0010000 है। दीर्घवृत्त का अर्थ है कि अभी भी कई शून्य हैं, लेकिन हम इस इकाई और इसके पीछे के शून्य में रुचि रखते हैं। यदि हम विचार करते हैं (16 -1), तो यह कुछ इस तरह दिखता है: (16 - 1) = ... 0001111। बाइनरी कोड में, इसका उलटा इस तरह दिखेगा: ~ (16-1) ... 1110000।





इस प्रकार, यह बात हमें मूल रूप से बिट को साफ करने की अनुमति देती है, जो अनिवार्य रूप से वर्तमान सूचक से प्रदान की जाएगी और हमें अपना आधार देगी। इसके लिए धन्यवाद, हमारे लिए यह जांचना बहुत सरल होगा कि यह सूचक सीमाओं के भीतर है या नहीं। इसलिए हम बस यह जांच सकते हैं कि (p ')> = आधार और क्या मान ( p' - आधार) चयनित आकार से छोटा है।



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

बुगी बाउंस चेकिंग की एक और अधिक, पांचवीं संपत्ति है - यह पॉइंटर के लिए निर्धारित सीमाओं से परे जाने से रोकने के लिए एक वर्चुअल मेमोरी सिस्टम का उपयोग करता है। मुख्य विचार यह है कि अगर हमारे पास पॉइंटर के लिए ऐसा अंकगणित है जिसके साथ हम बाहर का रास्ता निर्धारित करते हैं, तो हम पॉइंटर के लिए एक उच्च क्रम बिट सेट कर सकते हैं।



ऐसा करने से, हम गारंटी देते हैं कि पॉइंटर को डेरेफेर करने से हार्डवेयर की समस्या नहीं होगी। उच्च आदेश बिट को अपने आप पर सेट करने से समस्याएँ पैदा नहीं होती हैं, सूचक के डीरफ्रेंसिंग के कारण समस्या हो सकती है।


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

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