fuzzuf

fuzzuf (fuzzing unification framework) एक फ़ज़िंग फ्रेमवर्क है जिसमें फ़ज़िंग प्रिमिटिव के बिल्डिंग ब्लॉक्स को जोड़कर फ़ज़िंग लूप का वर्णन करने के लिए अपनी स्वयं की DSL है।

निर्माण निर्देशों और ट्यूटोरियल के लिए, कृपया building.md और tutorial.md का अनुसरण करें।

fuzzuf का उपयोग क्यों करें?

fuzzuf प्रत्येक फ़ज़र में परिभाषित फ़ज़िंग लूप की एक लचीली परिभाषा को सक्षम बनाता है, इसे DSL नोटेशन के साथ बिल्डिंग ब्लॉक्स के संयोजन के रूप में वर्णित करता है, साथ ही इसके मूल फ़ज़र के लिए विस्तारशीलता बनाए रखता है। इसमें पहले से ही AFL, VUzzer, और libFuzzer सहित विभिन्न फ़ज़र कार्यान्वयन हैं जिन्हें उपयोगकर्ताओं द्वारा और अधिक बढ़ाया जा सकता है।

HierarFlow

fuzzuf फ़ज़िंग लूप स्टेटमेंट के लिए HierarFlow नामक अपनी स्वयं की DSL का उपयोग करता है। इसे C++ भाषा के ऊपर इस प्रकार के व्याकरण के साथ कार्यान्वित किया गया है जो एक पेड़ संरचना जैसा दिखता है, ताकि फ़ज़िंग लूप को बिल्डिंग ब्लॉक्स के संयोजन के रूप में वर्णित किया जा सके।

HierarFlow के साथ, हम मौजूदा और नए दोनों फ़ज़र्स को साफ-सुथरे तरीके से लिख सकते हैं, क्योंकि फ़ज़िंग लूप की संरचना स्पष्ट रूप से दिखाई देती है। उदाहरण के लिए, हम एक AFL फ़ज़र (जो fuzzuf पर पहले से ही एक टेम्पलेट के रूप में कार्यान्वित है!) को कई फ़ज़िंग प्रिमिटिव में विभाजित कर सकते हैं जिनमें PUT निष्पादक, म्यूटेटर (नियतात्मक और यादृच्छिक दोनों), शब्दकोश अद्यतनकर्ता, इत्यादि शामिल हैं। उपयोगकर्ता प्रत्येक प्रिमिटिव को C++ कोड में कार्यान्वित कर सकते हैं और उन्हें HierarFlow के ऑपरेटर से जोड़कर अंततः उस फ़ज़र का फ़ज़िंग लूप बना सकते हैं जिसे वे प्राप्त करना चाहते हैं।

उदाहरण: HierarFlow में AFL

निम्नलिखित छोटा स्निपेट HierarFlow में AFL को दर्शाता है:

    fuzz_loop << (
         cull_queue
      || select_seed
    );

    select_seed << (
         consider_skip_mut
      || retry_calibrate
      || trim_case
      || calc_score
      || apply_det_muts << (
             bit_flip1 << execute << (normal_update || construct_auto_dict)
          || bit_flip_other << execute.HardLink() << normal_update.HardLink()
          || byte_flip1 << execute.HardLink() << (normal_update.HardLink()
                                               || construct_eff_map)
          || byte_flip_other << execute.HardLink() << normal_update.HardLink()
          || arith << execute.HardLink() << normal_update.HardLink()
          || interest << execute.HardLink() << normal_update.HardLink()
          || user_dict_overwrite << execute.HardLink() << normal_update.HardLink()
          || auto_dict_overwrite << execute.HardLink() << normal_update.HardLink()
         )
       || apply_rand_muts << (
               havoc << execute.HardLink() << normal_update.HardLink()
            || splicing << execute.HardLink() << normal_update.HardLink()
          )
       || abandon_node
    );

यह सरलता से दिखाता है कि HierarFlow कितना लचीला और शक्तिशाली है। अधिक जानकारी के लिए कृपया दस्तावेज़ देखें।

fuzzuf का उपयोग करने के लाभ

fuzzuf फ्रेमवर्क पर फ़ज़र लिखने के मुख्यतः चार लाभ हैं:

• प्रत्येक फ़ज़िंग प्रिमिटिव के संयोजन के साथ फ़ज़िंग लूप का वर्णन कर सकते हैं fuzzuf फ़ज़िंग प्रिमिटिव (फ़ज़िंग लूप में एक व्यक्तिगत चरण) को बिल्डिंग ब्लॉक्स की तरह जोड़कर एक फ़ज़िंग लूप का निर्माण करता है। चूंकि प्रत्येक ब्लॉक को जोड़ा, हटाया, बदला और पुन: उपयोग किया जा सकता है, fuzzuf प्रत्येक परिभाषित फ़ज़िंग लूप की उच्च मॉड्यूलरिटी बनाए रख सकता है।

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

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

• AFL फ़ज़र एक टेम्पलेट के रूप में fuzzuf पर, AFL एक फ़ज़र (C++) टेम्पलेट के रूप में भी उपलब्ध है। इसका मतलब है कि इसका उपयोग करके एक नए या मौजूदा AFL-आधारित फ़ज़र को लागू करने और समीक्षा करने की लागत बहुत कम हो गई है। उदाहरण के लिए, fuzzuf का AFLFast इस टेम्पलेट पर बनाया गया है। रूटीन और एक स्ट्रक्ट में केवल कुछ संशोधनों की आवश्यकता होती है जो फ़ज़र स्थिति रिकॉर्ड करता है, और यह इसके मूल प्रवाह को अपरिवर्तित रखता है।

वर्तमान में उपलब्ध फ़ज़र्स की सूची

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

Rust क्यों नहीं?

हमने फ्रेमवर्क को C++ से Rust में स्थानांतरित करने पर विचार किया था क्योंकि यह अधिक सुरक्षित है और विकास के दौरान इसका एक साफ-सुथरा पारिस्थितिकी तंत्र है। हालांकि, प्रयासों और चर्चाओं के बावजूद, हमने निष्कर्ष निकाला कि हम भाषा नहीं बदलेंगे। इसका कारण यहाँ विस्तार से बताया गया है।

API संदर्भ

doxygen द्वारा उत्पन्न API संदर्भ यहाँ उपलब्ध है।

लाइसेंस

fuzzuf GNU Affero General Public License v3.0 के तहत लाइसेंस प्राप्त है। बाहरी परियोजनाओं से उत्पन्न कुछ कोड अपने स्वयं के लाइसेंस के तहत लाइसेंस प्राप्त हैं। कृपया विवरण के लिए LICENSE देखें।

आभार

इस परियोजना को सुरक्षा 2020 (JPJ004596) के लिए अभिनव विज्ञान और प्रौद्योगिकी पहल के तहत अधिग्रहण, प्रौद्योगिकी और रसद एजेंसी (ATLA) से वित्त पोषण प्राप्त हुआ है।