यह फियरलेस प्रोटेक्शन लेख श्रृंखला का दूसरा भाग है। पहले हमने मेमोरी सिक्योरिटी के बारे में बात की थी

आधुनिक अनुप्रयोग बहु-थ्रेडेड होते हैं: क्रमिक रूप से निष्पादित कार्यों के बजाय, प्रोग्राम एक साथ कई कार्यों को करने के लिए थ्रेड्स का उपयोग करता है। हम सभी प्रतिदिन एक साथ काम करते हैं और संक्षिप्त रूप देते हैं:

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

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

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

प्रोग्रामिंग भाषाओं ने डेवलपर्स को बहु-थ्रेडेड अनुप्रयोगों के प्रदर्शन और सुरक्षा मुद्दों का प्रबंधन करने में मदद करने के लिए विभिन्न संगामिति रणनीतियों को विकसित किया है।

समसामयिक मुद्दे

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

गतिरोध तब होता है जब कई थ्रेड्स एक दूसरे से काम जारी रखने के लिए कुछ क्रियाएं करने की अपेक्षा करते हैं। हालांकि यह अवांछित व्यवहार सेवा हमले से इनकार कर सकता है, लेकिन यह एसीई जैसी कमजोरियों का कारण नहीं होगा।

दौड़ की स्थिति एक ऐसी स्थिति है जिसमें कार्यों का समय या क्रम किसी कार्यक्रम की शुद्धता को प्रभावित कर सकता है। डेटा रेस तब होती है जब कई स्ट्रीम एक ही मेमोरी लोकेशन पर एक साथ कम से कम एक लिखने के प्रयास को एक्सेस करने की कोशिश करते हैं। ऐसा होता है कि एक दौड़ की स्थिति और एक डेटा दौड़ स्वतंत्र रूप से एक दूसरे से होती है। लेकिन डेटा दौड़ हमेशा खतरनाक होती है ।

कंसीडर एरर्स के संभावित परिणाम

गतिरोध
जानकारी का नुकसान: एक और धागा जानकारी को अधिलेखित करता है
सत्यनिष्ठा की हानि: कई धाराओं की जानकारी आपस में जुड़ी हुई है
व्यवहार्यता हानि: साझा संसाधनों तक असमान पहुंच के कारण प्रदर्शन के मुद्दे

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

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

समवर्ती प्रोग्रामिंग का सबसे कठिन हिस्सा परीक्षण और डिबगिंग है, क्योंकि समवर्ती त्रुटियों को पुन: उत्पन्न करना कठिन है। घटनाओं का समय, ऑपरेटिंग सिस्टम के निर्णय, नेटवर्क ट्रैफ़िक और अन्य कारक ... यह सब प्रत्येक प्रारंभ में कार्यक्रम के व्यवहार को बदल देता है।

बग की तलाश करने के बजाय कभी-कभी पूरे कार्यक्रम को हटाना वास्तव में आसान होता है। Heisenbugs

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

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

सबसे पहले, हम "धागा सुरक्षा" की अवधारणा तैयार करते हैं:

"एक डेटा प्रकार या स्थिर विधि को थ्रेड सुरक्षित माना जाता है यदि यह कई थ्रेड्स से कॉल करने पर सही ढंग से व्यवहार करता है, भले ही इन थ्रेड्स को निष्पादित कैसे किया जाता है, और कॉलिंग कोड से अतिरिक्त समन्वय की आवश्यकता नहीं है।" एमआईटी

कैसे प्रोग्रामिंग भाषाएं समानता के साथ काम करती हैं

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

"लगातार सतर्कता!"

आमतौर पर, प्रोग्रामिंग भाषाएं दो दृष्टिकोणों तक सीमित होती हैं:

साझा पहुंच की परस्परता या प्रतिबंध की सीमा
मैनुअल थ्रेड सेफ्टी (उदा। लॉक, सेमाफोर)

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

इंटरप्रेटर द्वारा पाइथन और ग्लोबल लॉकिंग

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

जावा और रनटाइम अपवाद

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

यद्यपि जावा में थ्रेड सेफ प्रोग्राम बनाने के लिए बिल्डिंग ब्लॉक हैं, लेकिन संकलक द्वारा थ्रेड सुरक्षा की गारंटी नहीं है (स्मृति सुरक्षा के विपरीत)। यदि असंबद्ध मेमोरी एक्सेस (यानी डेटा रेस) होती है, तो जावा एक रन-टाइम अपवाद को फेंक देगा, लेकिन प्रोग्रामर को सही ढंग से कंसीडर प्राइमेटिव का उपयोग करना होगा।

सी ++ और प्रोग्रामर का मस्तिष्क

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

अधिकांश भाषाएँ थ्रेड-सुरक्षित कोड लिखने के लिए उपकरण प्रदान करती हैं, और डेटा रेस और रेस स्टेटस का पता लगाने के लिए विशेष तरीके हैं; लेकिन यह थ्रेड सुरक्षा की कोई गारंटी नहीं देता है और डेटा रेस से सुरक्षा नहीं देता है।

रस्ट की समस्या को कैसे हल करें?

रस्ट, कार्यकाल नियमों और सुरक्षित प्रकारों का उपयोग करते हुए संकलित समय पर पूरी तरह से दौड़ की स्थिति से बचाने के लिए दौड़ की शर्तों को समाप्त करने के लिए एक बहुआयामी दृष्टिकोण लेता है।

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

मूविंग थ्रो एक अपवाद है: कई थ्रेड्स एक ही मेमोरी में लिख सकते हैं, लेकिन एक ही समय में कभी नहीं। चूंकि मालिक हमेशा अकेला होता है, यदि कोई अन्य धागा एक चर उधार लेता है तो क्या होगा?

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

स्वामित्व अवधारणा स्मृति कमजोरियों को दूर करने के लिए डिज़ाइन की गई है। यह पता चला कि यह डेटा रेसिंग को भी रोकता है।

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

लेकिन रुकिए! यह सब नहीं है!

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

"एक अच्छी तरह से टाइप किया गया प्रोग्राम गलती नहीं कर सकता है।" - रॉबिन मिलनर, 1978

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

जंग एक प्रकार-सुरक्षित भाषा है, यहां कंपाइलर सभी प्रकारों की स्थिरता की जांच करता है। उदाहरण के लिए, निम्नलिखित कोड संकलित नहीं करता है:

let mut x = "I am a string"; x = 6;

  error[E0308]: mismatched types --> src/main.rs:6:5 | 6 | x = 6; // | ^ expected &str, found integral variable | = note: expected type `&str` found type `{integer}`

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

Send इंगित करता है कि संरचना को थ्रेड्स के बीच सुरक्षित रूप से स्थानांतरित किया जा सकता है (स्वामित्व स्थानांतरित करने के लिए आवश्यक)
Sync इंगित करता है कि थ्रेड संरचना का सुरक्षित रूप से उपयोग कर सकते हैं।

नीचे दिए गए उदाहरण मानक पुस्तकालय से कोड का एक सरलीकृत संस्करण है जो थ्रेड्स फैलाता है:

  fn spawn<Closure: Fn() + Send>(closure: Closure){ ... } let x = std::rc::Rc::new(6); spawn(|| { x; });

spawn फ़ंक्शन एक एकल तर्क लेता है, closure और बाद के लिए एक प्रकार की आवश्यकता होती है जो Send और Fn लक्षणों को लागू करता है। जब एक स्ट्रीम बनाने और चर x साथ closure मान को पास करने की कोशिश की जाती है x संकलक एक त्रुटि फेंकता है:

  त्रुटि [E0277]: `std :: rc :: Rc <i32>` को थ्रेड्स के बीच सुरक्षित रूप से नहीं भेजा जा सकता है
      -> src / main.rs: 8: 1
       |
     8 |  स्पॉन (चाल || {x;});
       |  ^ ^ ^ ^ ^ ^ ^ std :: rc :: Rc <i32> `को थ्रेड्स के बीच सुरक्षित रूप से नहीं भेजा जा सकता है
       |
       = मदद: भीतर [[closure@src/main.rs: 8: 7: 8:21 x: std :: rc :: Rc <i32>] `, गुण` std :: मार्कर :: Send` लागू नहीं किया गया है `std :: rc :: Rc <i32>` के लिए
       = ध्यान दें: आवश्यक है क्योंकि यह टाइप के भीतर दिखाई देता है `[closure@src/main.rs: 8: 7: 8:21 x: std :: rc :: Rc <i32>]`
     नोट: `स्पॉन` द्वारा आवश्यक

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

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

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

निडर संरक्षण। थ्रेड सुरक्षा जंग में