फ़ज़ मॉड्यूल

रस्ट फ़ज़िंग को libfuzzer-sys क्रेट के माध्यम से समर्थित किया जाता है, जो LLVM के libFuzzer फ़ज़िंग इंजन को बाइंडिंग प्रदान करता है। अधिक जानकारी के लिए, libfuzzer-sys रिपॉजिटरी के साथ-साथ LLVM libFuzzer प्रोजेक्ट पेज देखें।

rust_fuzz मॉड्यूल एक फ़ज़र बाइनरी उत्पन्न करता है जो चलने पर फ़ज़ करना शुरू कर देता है ( cc_fuzz मॉड्यूल के समान)। चूंकि फ़ज़र libFuzzer फ़ज़िंग इंजन का लाभ उठाता है, फ़ज़िंग को नियंत्रित करने के लिए इसे कई तर्कों की आवश्यकता हो सकती है। इन्हें libFuzzer दस्तावेज़ में सूचीबद्ध किया गया है।

rust_fuzz मॉड्यूल rust_binary मॉड्यूल का एक विस्तार है, और इस तरह समान गुण और विचार साझा करते हैं। इसके अतिरिक्त, वे cc_fuzz मॉड्यूल के समान ही कई गुण और कार्यक्षमता लागू करते हैं।

rust_fuzz मॉड्यूल का निर्माण करते समय, --cfg fuzzing फ़्लैग उत्सर्जित होता है जिसका उपयोग फ़ज़िंग को बेहतर बनाने के लिए लाइब्रेरी कोड के सशर्त संकलन का समर्थन करने के लिए किया जा सकता है।

एक बुनियादी रस्ट फ़ज़र लिखें

आप इस कोड के साथ Android.bp बिल्ड फ़ाइल में फ़ज़ मॉड्यूल को परिभाषित कर सकते हैं:

rust_fuzz {
    name: "example_rust_fuzzer",
    srcs: ["fuzzer.rs"],

    // Config for running the target on fuzzing infrastructure can be set under
    // fuzz_config. This shares the same properties as cc_fuzz's fuzz_config.
    fuzz_config: {
        fuzz_on_haiku_device: true,
        fuzz_on_haiku_host: false,
    },

    // Path to a corpus of sample inputs, optional. See https://llvm.org/docs/LibFuzzer.html#corpus
    corpus: ["testdata/*"],

    // Path to a dictionary of sample byte sequences, optional. See https://llvm.org/docs/LibFuzzer.html#dictionaries
    dictionary: "example_rust_fuzzer.dict",
}

fuzzer.rs फ़ाइल में एक साधारण फ़ज़र है:

fn heap_oob() {
    let xs = vec![0, 1, 2, 3];
    let val = unsafe { *xs.as_ptr().offset(4) };
    println!("Out-of-bounds heap value: {}", val);
}

fuzz_target!(|data: &[u8]| {
    let magic_number = 327;
    if data.len() == magic_number {
        heap_oob();
    }
});

यहां fuzz_target!(|data: &[u8]| { /* fuzz using data here */ }); libFuzzer इंजन द्वारा बुलाए गए फ़ज़-लक्ष्य प्रविष्टि-बिंदु को परिभाषित करता है। data तर्क libFuzzer इंजन द्वारा प्रदान किए गए बाइट्स का एक अनुक्रम है जिसे लक्षित फ़ंक्शन को फ़ज़ करने के लिए इनपुट के रूप में हेरफेर किया जाता है।

इस उदाहरण फ़ज़र में, केवल डेटा की लंबाई की जाँच यह निर्धारित करने के लिए की जाती है कि क्या heap_oob फ़ंक्शन को कॉल करना है, जिसके कॉलिंग के परिणामस्वरूप आउट-ऑफ़-बाउंड रीड होता है। libFuzzer एक कवरेज-निर्देशित फ़ज़र है, इसलिए यह समस्याग्रस्त लंबाई पर जल्दी से परिवर्तित हो जाता है क्योंकि यह निर्धारित करता है कि पहले 326 B डेटा के परिणामस्वरूप नए निष्पादन पथ नहीं बनते हैं।

इस उदाहरण को, इन-ट्री, टूल्स/सुरक्षा/फ़ज़िंग/example_rust_fuzzer/ पर ढूंढें। पेड़ में एक अन्य फ़ज़र (जो एक rustlib निर्भरता को फ़ज़ करता है) का थोड़ा अधिक जटिल उदाहरण देखने के लिए, लिगेसी_ब्लॉब_फ़ज़र देखें।

संरचना-जागरूक रस्ट फ़ज़र्स लिखने के तरीके पर मार्गदर्शन के लिए, रस्ट फ़ज़ पुस्तक देखें, जो रस्ट फ़ज़ प्रोजेक्ट के लिए आधिकारिक दस्तावेज़ है।