nautilus-fuzz/nautilusव्याकरण आधारित फीडबैक फज़र
Nautilus एक कवरेज-निर्देशित, व्याकरण-आधारित फजर है। आप इसका उपयोग अपने परीक्षण कवरेज को बेहतर बनाने और अधिक बग खोजने के लिए कर सकते हैं। अर्ध-मान्य इनपुट के व्याकरण को निर्दिष्ट करके, Nautilus जटिल उत्परिवर्तन करने और अधिक दिलचस्प परीक्षण मामलों को उजागर करने में सक्षम है। इस फजर के पीछे कई विचार NDSS 2019 में प्रकाशित एक पेपर में दस्तावेज़ित किए गए हैं।
संस्करण 2.0 ने इस प्रारंभिक प्रोटोटाइप में कई सुधार जोड़े हैं और अब यह AFL++ के साथ 100% संगत है। सामान्य उपयोगिता सुधारों के अलावा, संस्करण 2.0 में बहुत सी नई सुविधाएँ शामिल हैं:
आप EXPR -> EXPR + EXPR या EXPR -> NUM और NUM -> 1 जैसे नियमों का उपयोग करके एक व्याकरण निर्दिष्ट करते हैं। इन नियमों से, फजर एक ट्री का निर्माण करता है। यह आंतरिक प्रस्तुति रॉ बाइट्स की तुलना में अधिक जटिल उत्परिवर्तन लागू करने की अनुमति देती है। फिर इस ट्री को लक्ष्य एप्लिकेशन के लिए एक वास्तविक इनपुट में बदल दिया जाता है। सामान्य संदर्भ मुक्त व्याकरणों में, यह प्रक्रिया सीधी है: सभी पत्तियों को संयोजित किया जाता है। नीचे दिए गए उदाहरण में बायाँ ट्री इनपुट a=1+2 में अनपार्स होगा और दायाँ a=1+1+1+2 में। अपने व्याकरणों की अभिव्यक्तता बढ़ाने के लिए, Nautilus का उपयोग करके आप अनपार्सिंग प्रक्रिया के लिए Python फ़ंक्शन प्रदान कर सकते हैं ताकि अधिक जटिल विशिष्टताओं की अनुमति मिल सके।
# checkout the git
git clone '[email protected]:nautilus-fuzz/nautilus.git'
cd nautilus
/path/to/AFLplusplus/afl-clang-fast test.c -o test #afl-clang-fast as provided by AFL
# all arguments can also be set using the config.ron file
cargo run --release -- -g grammars/grammar_py_example.py -o /tmp/workdir -- ./test @@
# or if you want to use QEMU mode:
cargo run /path/to/AFLplusplus/afl-qemu-trace -- ./test_bin @@
यहाँ, हम Python का उपयोग करके वैध xml-जैसे इनपुट के लिए एक व्याकरण उत्पन्न करते हैं। उद्घाटन और समापन टैग मेल खाने के लिए एक स्क्रिप्ट नियम के उपयोग पर ध्यान दें।
#ctx.rule(NONTERM: string, RHS: string|bytes) adds a rule NONTERM->RHS. We can use {NONTERM} in the RHS to request a recursion.
ctx.rule("START","<document>{XML_CONTENT}</document>")
ctx.rule("XML_CONTENT","{XML}{XML_CONTENT}")
ctx.rule("XML_CONTENT","")
#ctx.script(NONTERM:string, RHS: [string]], func) adds a rule NONTERM->func(*RHS).
# In contrast to normal `rule`, RHS is an array of nonterminals.
# It's up to the function to combine the values returned for the NONTERMINALS with any fixed content used.
ctx.script("XML",["TAG","ATTR","XML_CONTENT"], lambda tag,attr,body: b"<%s %s>%s</%s>"%(tag,attr,body,tag) )
ctx.rule("ATTR","foo=bar")
ctx.rule("TAG","some_tag")
ctx.rule("TAG","other_tag")
#sometimes we don't want to explore the set of possible inputs in more detail. For example, if we fuzz a script
#interpreter, we don't want to spend time on fuzzing all different variable names. In such cases we can use Regex
#terminals. Regex terminals are only mutated during generation, but not during normal mutation stages, saving a lot of time.
#The fuzzer still explores different values for the regex, but it won't be able to learn interesting values incrementally.
#Use this when incremantal exploration would most likely waste time.
ctx.regex("TAG","[a-z]+")
अपने व्याकरणों का परीक्षण करने के लिए आप जनरेटर का उपयोग कर सकते हैं:
$ cargo run --bin generator -- -g grammars/grammar_py_exmaple.py -t 100
<document><some_tag foo=bar><other_tag foo=bar><other_tag foo=bar><some_tag foo=bar></some_tag></other_tag><some_tag foo=bar><other_tag foo=bar></other_tag></some_tag><other_tag foo=bar></other_tag><some_tag foo=bar></some_tag></other_tag><other_tag foo=bar></other_tag><some_tag foo=bar></some_tag></some_tag></document>
आप Nautilus का उपयोग AFL के साथ संयोजन में भी कर सकते हैं। बस AFL के -o को उसी कार्य निर्देशिका पर इंगित करें, और AFL Nautilus के साथ सिंक्रोनाइज़ हो जाएगा। ध्यान दें कि यह एकतरफा है। AFL Nautilus के इनपुट आयात करता है, लेकिन इसके विपरीत नहीं।
#Terminal/Screen 1
./afl-fuzz -Safl -i /tmp/seeds -o /tmp/workdir/ ./test @@
#Terminal/Screen 2
cargo run --release -- -o /tmp/workdir -- ./test @@