मोज़िला ने पिछले साल फ़ायरफ़ॉक्स के लिए क्वांटम सीएसएस जारी किया था, जो कि मेमोरी के अनुकूल सिस्टम प्रोग्रामिंग भाषा रस्ट को विकसित करने के आठ वर्षों में समाप्त हुआ। रस्ट में मुख्य ब्राउज़र घटक को फिर से लिखने में एक वर्ष से अधिक समय लगा।

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

मेमोरी सुरक्षा क्या है?

जब हम सुरक्षित एप्लिकेशन बनाने के बारे में बात करते हैं, तो हम अक्सर मेमोरी सुरक्षा का उल्लेख करते हैं। अनौपचारिक रूप से, हमारा मतलब है कि किसी भी स्थिति में कार्यक्रम अमान्य मेमोरी तक नहीं पहुंच सकता है। सुरक्षा उल्लंघनों के कारण:

• मेमोरी को मुक्त करने के बाद पॉइंटर को सहेजना (उपयोग-बाद-मुक्त);
  
• एक अशक्त सूचक dereferencing;
  
• एकतरफा स्मृति का उपयोग;
  
• कार्यक्रम एक ही सेल को दो बार (डबल-फ्री) मुक्त करने का प्रयास करता है;
  
• बफर अतिप्रवाह।

अधिक औपचारिक परिभाषा के लिए, माइकल हिक्स की मेमोरी सुरक्षा क्या है , साथ ही इस विषय पर एक वैज्ञानिक लेख देखें ।

इस तरह के उल्लंघन से कार्यक्रम के अपेक्षित व्यवहार में अप्रत्याशित दुर्घटना या परिवर्तन हो सकता है। संभावित परिणाम: सूचना रिसाव, मनमाना कोड निष्पादन और रिमोट कोड निष्पादन।

मेमोरी प्रबंधन

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

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

आवंटन / रिलीज

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

बफ़र्स

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

नियंत्रण प्रवाह

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

1. प्रक्रिया सामान्य रूप से जारी रहती है (रिटर्न पता परिवर्तित नहीं होता है)।
   
2. प्रक्रिया क्रैश (पता बदल दिया गया है और गैर-निष्पादन योग्य मेमोरी को इंगित करता है)।
   
3. प्रक्रिया जारी है, लेकिन उम्मीद के मुताबिक नहीं (वापसी पता बदल गया है और नियंत्रण प्रवाह बदल गया है)।

भाषाएं स्मृति सुरक्षा कैसे प्रदान करती हैं

सभी प्रोग्रामिंग भाषाएं स्पेक्ट्रम के विभिन्न हिस्सों से संबंधित हैं। स्पेक्ट्रम के एक तरफ C / C ++ जैसी भाषाएं हैं। वे प्रभावी हैं, लेकिन मैन्युअल मेमोरी प्रबंधन की आवश्यकता है। दूसरी ओर, स्वचालित मेमोरी प्रबंधन (उदाहरण के लिए, संदर्भ गिनती और कचरा संग्रह) (जीसी) के साथ भाषाओं की व्याख्या की जाती है, लेकिन वे प्रदर्शन के लिए भुगतान करते हैं। यहां तक ​​कि अच्छी तरह से अनुकूलित कचरा संग्रह वाली भाषाएं जीसी के बिना भाषाओं के साथ प्रदर्शन में तुलना नहीं कर सकती हैं।

मैनुअल मेमोरी प्रबंधन

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

त्रुटियां जो आसान हैं:

• भूल जाते हैं कि संसाधन स्वतंत्र हैं और उनका उपयोग करने की कोशिश करते हैं;
  
• डेटा भंडारण के लिए पर्याप्त स्थान आवंटित न करें;
  
• बफर के बाहर मेमोरी पढ़ें।

स्मृति का प्रबंधन करने वालों के लिए उपयुक्त सुरक्षा निर्देश

स्मार्ट पॉइंटर्स

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

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

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

कचरा संग्रह

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

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

अधिकार

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

1. प्रत्येक मान में एक चर होता है जिसे मालिक कहा जाता है।
   
2. एक बार में केवल एक ही मालिक हो सकता है।
   
3. जब मालिक दायरे से बाहर हो जाता है, तो मूल्य हटा दिया जाता है।

मूल्यों को एक चर से दूसरे में स्थानांतरित या उधार लिया जा सकता है। ये नियम संकलक के एक हिस्से पर लागू होते हैं जिसे उधारकर्ता चेकर कहा जाता है।

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

उदाहरण 1 : स्वामित्व का हस्तांतरण

 let s1 = String::from("hello"); let s2 = s1; //won't compile because s1 is now invalid println!("{}, world!", s1); 

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

उदाहरण 2 : हैंगिंग पॉइंटर

 let r; { let x = 5; r = &x; } println!("r: {}", r); 

स्वामित्व मॉडल अपरिभाषित व्यवहार को रोकने के लिए, स्मृति तक सही पहुंच के लिए एक ठोस आधार प्रदान करता है।

याददाश्त कमजोर होना

कमजोर स्मृति के मुख्य परिणाम:

1. क्रैश : अमान्य मेमोरी तक पहुँचने से अनपेक्षित अनुप्रयोग समाप्ति हो सकती है।
   
2. सूचना रिसाव : गोपनीय जानकारी, जैसे पासवर्ड, सहित निजी डेटा का अनजाने में प्रावधान।
   
3. मनमाना कोड निष्पादन (ACE) : किसी हमलावर को लक्ष्य मशीन पर मनमाना आदेश निष्पादित करने की अनुमति देता है। यदि नेटवर्क पर ऐसा होता है, तो हम इसे दूरस्थ कोड निष्पादन (RCE) कहते हैं।

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

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

मुक्त स्मृति का दुरुपयोग (उपयोग-मुक्त, डबल मुक्त)

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

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

Uninitialized चर

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

जैसा कि C में है, Rust में अधिकांश वैरिएबल्स को शुरू में आरंभिक नहीं किया गया है। लेकिन C के विपरीत, आप उन्हें आरंभीकरण से पहले नहीं पढ़ सकते हैं। निम्नलिखित कोड संकलित नहीं करता है:

उदाहरण 3 : एक असिंचित चर का उपयोग करना

 fn main() { let x: i32; println!("{}", x); } 

अशक्त संकेत

जब कोई एप्लिकेशन एक पॉइंटर को पॉइंटर करता है जो शून्य हो जाता है, तो यह आमतौर पर कचरे को एक्सेस करता है और क्रैश का कारण बनता है। कुछ मामलों में, इन कमजोरियों से मनमाना कोड ( 1 , 2 , 3 ) का निष्पादन हो सकता है। रस्ट में दो प्रकार के पॉइंटर्स होते हैं: लिंक और रॉ पॉइंटर्स। लिंक सुरक्षित हैं, लेकिन कच्चे संकेत समस्या हो सकती है।

जंग दो तरीकों से अशक्त सूचक को रोकती है:

1. अशक्त बिंदुओं से बचें।
   
2. कच्चे पॉइंटर्स को डीफ़र करने से बचें।

रस्ट विशेष Option साथ बदलकर अशक्त बिंदुओं से बचता है। Option प्रकार में संभव-शून्य मान को बदलने के लिए, भाषा को प्रोग्रामर को स्पष्ट रूप से एक शून्य मान के साथ मामले को संभालने की आवश्यकता होती है, अन्यथा कार्यक्रम संकलित नहीं करेगा।

यदि एक शून्य मान की अनुमति देने वाले पॉइंटर्स से बचा जा सकता है (उदाहरण के लिए, किसी अन्य भाषा में कोड के साथ बातचीत करते समय) तो क्या करें? क्षति को अलग करने का प्रयास करें। एक अलग असुरक्षित ब्लॉक में कच्चे पॉइंटर्स की डीफ्रेंसिंग होनी चाहिए। यह रस्ट नियमों को ढीला करता है और कुछ ऑपरेशनों को हल करता है जो अपरिभाषित व्यवहार का कारण हो सकता है (उदाहरण के लिए, एक कच्चे सूचक को dereferencing)।


"उधार लेने वाले के बारे में सब कुछ ... उस अंधेरी जगह के बारे में क्या?"
- यह एक असुरक्षित ब्लॉक है। वहां कभी मत जाओ, सिम्बा

बफर ओवरफ्लो

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

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

उदाहरण 4: बफर अतिप्रवाह (सी कोड)

 int main() { int buf[] = {0, 1, 2, 3, 4}; // print out of bounds printf("Out of bounds: %d\n", buf[10]); // write out of bounds buf[10] = 10; printf("Out of bounds: %d\n", buf[10]); return 0; } 

बफर ओवरफ्लो के खिलाफ सबसे सरल सुरक्षा हमेशा तत्वों की पहुंच के दौरान सीमा जांच की आवश्यकता होती है, लेकिन इससे खराब प्रदर्शन होता है ।

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

मेमोरी सुरक्षा केवल आधी लड़ाई है

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

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

मेमोरी कमजोरियों का शोषण: अतिरिक्त संसाधन

• स्मृति और शोषण का ढेर
  
• एक हैकर स्थिति से एक ढेर का विनाश
  
• सूचना सुरक्षा उपमाएँ
  
• उपयोग के बाद मुक्त कमजोरियों का परिचय