कल्पना कीजिए कि आप एक जासूस हैं जो एक विशाल, हलचल भरे शहर में एक एकल, नन्हे से दोष को खोजने की कोशिश कर रहे हैं। कंप्यूटर सॉफ़्टवेयर की दुनिया में, यह प्रोग्राम एक शहर है, और वह दोष एक "मेमोरी बग" (memory bug) है—एक ऐसी गलती जहाँ प्रोग्राम उस डेटा को लेने, उपयोग करने या फेंकने की कोशिश करता है जिसे उसे नहीं करना चाहिए, जिससे वह क्रैश हो जाता है या हैक हो जाता है। दशकों से, इन बग्स को खोजने का सबसे लोकप्रिय तरीका "फज़िंग" (fuzzing) रहा है। फज़िंग को ऐसे समझें जैसे शहर की दीवारों पर लाखों रैंडम, अराजक बर्फ के गोले (snowballs) फेंकना ताकि यह देखा जा सके कि क्या कोई खिड़की टूटती है। आमतौर पर, यह पुराने प्रोग्रामिंग भाषाओं के लिए अच्छा काम करता है, लेकिन इसमें एक पेंच है: यह अविश्वसनीय रूप से अक्षम है। आप पीछे की गली में एक कमजोर खिड़की खोजने के लिए मज़बूत, अटूट सामने के दरवाजे पर 99 बर्फ के गोले फेंक सकते हैं।

यहाँ रस्ट (Rust) आता है, एक आधुनिक प्रोग्रामिंग भाषा जो एक अत्यंत सख्त सुरक्षा गार्ड की तरह काम करती है। इसके नियम इतने अच्छे हैं कि इसके द्वारा बनाया गया 90% शहर व्यावहारिक रूप से बुलेटप्रूफ है; गार्ड यह सुनिश्चित करता है कि अधिकांश "खिड़कियाँ" (मेमोरी क्षेत्र) डिफ़ॉल्ट रूप से मजबूती से बंद रहें। हालाँकि, कुछ जटिल चीजें बनाने के लिए, रस्ट डेवलपर्स को "अनसेफ कोड" (unsafe code) नामक एक छोटा, विशेष गेट खोलने की अनुमति देता है। यह एकमात्र जगह है जहाँ सख्त नियम शिथिल होते हैं, और यही वह एकमात्र स्थान है जहाँ मेमोरी बग छिप सकता है। समस्या यह है कि मौजूदा "बर्फ के गोले फेंकने वाले" टूल्स को यह पता नहीं होता। वे उस 90% शहर पर बर्फ के गोले फेंकते रहते हैं जो पहले से ही सुरक्षित है, जबकि वे उस विशेष गेट के पीछे छिपे कुछ खतरनाक स्थानों को मिस कर देते हैं। यह पेपर एक नए जासूसी टूल RustGo को पेश करता है जो खेल बदल देता है क्योंकि इसे पता होता है कि बर्फ के गोले कहाँ फेंकने हैं।

स्मार्ट डिटेक्टिव: RustGo

इस पेपर के पीछे के शोधकर्ताओं ने, जो कोरिया यूनिवर्सिटी और अन्य संस्थानों की एक टीम है, महसूस किया कि रस्ट प्रोग्राम पर रैंडम तरीके से बर्फ के गोले फेंकना, पूरे घास के ढेर को जलाकर उसमें से सुई खोजने की कोशिश करने जैसा है। चूंकि रस्ट अपने कोड के अधिकांश हिस्से के लिए सुरक्षा की गारंटी देता है, इसलिए उन्होंने पूछा: सुरक्षित हिस्सों का परीक्षण करने की आवश्यकता ही क्यों है? उन्होंने RustGo बनाया, जो एक "डायरेक्टेड ग्रेबॉक्स फज़र" (directed greybox fuzzer) है जो एक अंधे व्यक्ति की तरह पत्थर फेंकने के बजाय, नक्शे और आवर्धक लेंस (magnifying glass) वाले एक जासूस की तरह काम करता है।

RustGo बग्स को कुशलतापूर्वक खोजने के लिए तीन चतुर चरणों में काम करता है:

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

2. डेड एंड को काटना (आवर्धक लेंस)
एक बार जब RustGo जान लेता है कि कहाँ देखना है, तो इसे बाकी शहर को अनदेखा करने की आवश्यकता होती है। पुराने फज़िंग टूल्स में, शहर का "नक्शा" अक्सर स्टैंडर्ड लाइब्रेरी (वे प्री-बिल्ट टूल्स जिनका रस्ट उपयोग करता है) को भी शामिल करता था, जो बहुत बड़ा है और ऐसे रास्तों से भरा है जो पहुँच योग्य लगते हैं लेकिन वास्तव में नहीं होते। इसने टूल्स को भ्रमित कर दिया, जिससे वे बेकार क्षेत्रों की खोज करने में समय लगाने लगे। RustGo ने "टारगेट-स्पेसिफिक पाथ प्रूनिंग" (target-specific path pruning) नामक एक नया तरीका पेश किया। यह एक जादुई बाड़ की तरह है जो तुरंत किसी भी ऐसे पथ को गायब कर देता है जो आपके वर्तमान लक्ष्य तक नहीं ले जाता है। यदि जासूस बेकरी में बग की तलाश कर रहा है, तो बाड़ लाइब्रेरी या पार्क की ओर जाने वाले रास्तों को ब्लॉक कर देती है, भले ही वे तकनीकी रूप से शहर में मौजूद हों। इसने RustGo को उन 78.49% अप्रासंगिक रास्तों को काटने की अनुमति दी जिन्हें अन्य टूल्स खोजने में समय बर्बाद करते।

3. निष्पक्ष खेलना (राउंड-रॉबिन रणनीति)
यहाँ अंतिम, महत्वपूर्ण मोड़ है। जब एक जासूस के पास जांचने के लिए कई संदिग्ध (लक्ष्य) होते हैं, तो पुराने टूल्स अक्सर सबसे आसान लक्ष्य के प्रति जुनूनी हो जाते हैं और कठिन वाले को अनदेखा कर देते हैं। RustGo एक "डायनेमिक फेयर टॉगलिंग" (dynamic fair toggling) सिस्टम का उपयोग करता है। कल्पना कीजिए कि एक रेफरी संदिग्धों के बीच जासूस का ध्यान एक आदर्श रोटेशन में बदलता है। यदि जासूस संदिग्ध A पर बहुत अधिक समय बिताता है, तो रेफरी तुरंत उसे संदिग्ध B की ओर मोड़ देता है, यह सुनिश्चित करता है कि हर संदिग्ध को उचित ध्यान मिले। RustGo यह काम प्रत्येक लक्ष्य को उसके अपने "क्यू" (queue) और प्रगति को ट्रैक करने के लिए अपने स्वयं के "स्कोरकार्ड" देकर करता है। यह सुनिश्चित करता है कि कोई भी खतरनाक स्थान केवल इसलिए अनटेस्टेड न रह जाए क्योंकि वह थोड़ा कठिन है।

परिणाम: तेज़ और स्मार्ट

टीम ने 13 वास्तविक दुनिया के रस्ट एप्लिकेशन्स पर RustGo का परीक्षण किया, जिनमें वेब सर्वर से लेकर डेटा प्रोसेसिंग टूल्स तक शामिल हैं। उन्होंने इसकी तुलना AFL++ और कई विशेष "डायरेक्टेड" फज़र्स सहित बेहतरीन मौजूदा टूल्स से की। परिणाम चौंकाने वाले थे।

चूंकि RustGo ने कोड के सुरक्षित 90% हिस्से पर समय बर्बाद करना बंद कर दिया और पूरी तरह से खतरनाक 10% पर ध्यान केंद्रित किया, इसलिए इसने अन्य टूल्स की तुलना में 2.09 से 5.08 गुना तेज़ दर से कमजोरियों को खोजा। कुछ मामलों में, जैसे कि gimli एप्लिकेशन, यह 10 गुना से भी अधिक तेज़ था। इसे समझने के लिए, यदि एक पुराने टूल को बग खोजने में 10 घंटे लगते, तो RustGo ने इसे एक घंटे से भी कम समय में खोज लिया।

लेकिन गति ही एकमात्र जीत नहीं है। टीम ने RustGo का उपयोग केवल अपने लैब में नहीं, बल्कि असली दुनिया में बग्स खोजने के लिए किया। उन्होंने वास्तविक दुनिया के सॉफ़्टवेयर में 13 पहले से अज्ञात मेमोरी बग्स की खोज की। इनमें से, 10 की पुष्टि सॉफ़्टवेयर डेवलपर्स द्वारा की गई, और 8 को पहले ही ठीक किया जा चुका है। इससे भी अधिक प्रभावशाली बात यह है कि 6 बग्स को आधिकारिक सुरक्षा आईडी (RUSTSEC) दी गई, और एक को CVE ID मिली, जो गंभीर सुरक्षा खामियों को ट्रैक करने का वैश्विक मानक है। यह साबित करता है कि RustGo केवल एक सैद्धांतिक विचार नहीं है; यह एक व्यावहारिक उपकरण है जो पहले से ही सॉफ़्टवेयर को सुरक्षित बना रहा है।

यह क्यों मायने रखता है

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

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

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