FormatFuzzer

FormatFuzzer एक फ्रेमवर्क है जो उच्च दक्षता, उच्च गुणवत्ता वाले बाइनरी इनपुटों के निर्माण और पार्सिंग के लिए है। यह एक बाइनरी टेम्पलेट लेता है जो बाइनरी इनपुट के प्रारूप का वर्णन करता है और एक निष्पादनीय उत्पन्न करता है जो दिए गए बाइनरी प्रारूप का उत्पादन और पार्स करता है। उदाहरण के लिए, GIF के लिए एक बाइनरी टेम्पलेट से, FormatFuzzer एक GIF जनरेटर उत्पन्न करता है - जिसे GIF फ़ज़र भी कहा जाता है।

FormatFuzzer द्वारा उत्पादित जनरेटर अत्यधिक कुशल होते हैं, प्रति सेकंड हजारों मान्य परीक्षण इनपुट उत्पन्न करते हैं - उत्परिवर्तन-आधारित फ़ज़रों के बिल्कुल विपरीत, जहाँ अधिकांश इनपुट अमान्य होते हैं। FormatFuzzer द्वारा उत्पन्न इनपुट परीक्षण के अंतर्गत प्रोग्राम से स्वतंत्र होते हैं (या वास्तव में, किसी भी प्रोग्राम से), इसलिए आप उनका उपयोग ब्लैक-बॉक्स सेटिंग्स में भी कर सकते हैं। हालाँकि, FormatFuzzer अधिकतम कवरेज के लिए लक्ष्य रखने वाले मान्य इनपुट उत्पन्न करने के लिए AFL++ के साथ भी एकीकृत होता है। हमारे प्रयोगों में, यह "दो दुनियाओं का सर्वश्रेष्ठ" दृष्टिकोण अन्य सभी सेटिंग्स से आगे निकल जाता है; विवरण के लिए हमारा शोधपत्र देखें।

FormatFuzzer द्वारा उपयोग किए जाने वाले बाइनरी टेम्पलेट 010 संपादक से आते हैं। 170 से अधिक बाइनरी टेम्पलेट हैं, जिनका उपयोग सीधे FormatFuzzer के लिए किया जा सकता है या इसके उपयोग के लिए अनुकूलित किया जा सकता है। बॉक्स के बाहर, FormatFuzzer AVI, BMP, GIF, JPG, MIDI, MP3, MP4, PCAP, PNG, WAV और ZIP जैसे प्रारूप उत्पन्न करता है; और हम हर सप्ताह इस सूची का विस्तार करते रहते हैं।

योगदानकर्ताओं का स्वागत है! विचारों और मुद्दों को दर्ज करने या पुल रिक्वेस्ट जोड़ने के लिए FormatFuzzer प्रोजेक्ट पेज पर जाएँ। FormatFuzzer कैसे काम करता है और इसकी तुलना कैसे होती है, इसके विवरण के लिए हमारा शोधपत्र पढ़ें।

प्राप्त करना

FormatFuzzer FormatFuzzer प्रोजेक्ट पेज से उपलब्ध है। आप रिलीज़ पेज से नवीनतम रिलीज़ डाउनलोड और अनपैक कर सकते हैं।

नवीनतम और सर्वश्रेष्ठ के लिए, आप इसका git रिपॉजिटरी क्लोन भी कर सकते हैं:

git clone https://github.com/uds-se/FormatFuzzer.git

सभी आगे की कार्रवाइयाँ इसके मुख्य फ़ोल्डर में होती हैं:

cd FormatFuzzer

पूर्वापेक्षाएँ

FormatFuzzer चलाने के लिए, आपको निम्नलिखित की आवश्यकता है:

• Python 3
• GNU लाइब्रेरीज़ (विशेष रूप से getopt_long()) के साथ एक C++ कंपाइलर जैसे clang या gcc
• Python पैकेज py010parser, six, और intervaltree
• एक zlib लाइब्रेरी (संपीड़न कार्यों के लिए)
• एक boost लाइब्रेरी (चेकसम कार्यों के लिए)

यदि आप बिल्ड और कॉन्फ़िगरेशन स्क्रिप्ट (.ac और .am फ़ाइलें) संपादित करने की योजना बनाते हैं, तो आपको इसकी भी आवश्यकता होगी:

• GNU autoconf
• GNU automake

लिनक्स पर आवश्यकताएँ स्थापित करना (डेबियन पैकेज, पायथन आभासी वातावरण का उपयोग करके)

sudo apt install git g++ make automake python3-full zlib1g-dev libboost-dev
python3 -m venv ~/fuzz
source ~/fuzz/bin/activate
pip3 install py010parser six intervaltree

MacOS पर आवश्यकताएँ स्थापित करना (Xcode और Homebrew के साथ)

xcode-select --install
brew install python3 automake boost
pip3 install py010parser six intervaltree

केवल पायथन पैकेज स्थापित करना (सभी ऑपरेटिंग सिस्टम)

सभी सिस्टम पर, pip का उपयोग करके:

pip install py010parser
pip install six
pip install intervaltree

बिल्ड करना

नोट: सभी बिल्ड कमांड के लिए आपको इस README फ़ाइल वाले फ़ोल्डर में होना आवश्यक है। इस फ़ोल्डर के बाहर फ़ज़र बनाना अभी तक समर्थित नहीं है।

विधि 1: build.sh स्क्रिप्ट का उपयोग करना

एक build.sh स्क्रिप्ट है जो सभी निर्माण चरणों को स्वचालित करती है। बस चलाएँ:

./build.sh gif

एक GIF फ़ज़र बनाने के लिए।

यह templates/ में प्रदान किए गए सभी फ़ाइल प्रारूपों के लिए काम करता है; यदि कोई फ़ाइल templates/FOO.bt है, तो ./build.sh FOO एक फ़ज़र बनाएगा।

विधि 2: Make का उपयोग करना

एक Makefile (स्रोत Makefile.am में) है जो सभी निर्माण चरणों को स्वचालित करता है। (GNU make आवश्यक है।) पहले करें:

touch configure Makefile.in

फिर:

./configure

और फिर:

make gif-fuzzer

एक GIF फ़ज़र बनाने के लिए।

यह templates/ में प्रदान किए गए सभी फ़ाइल प्रारूपों के लिए काम करता है; यदि कोई फ़ाइल templates/FOO.bt है, तो make FOO-fuzzer एक फ़ज़र बनाएगा।

विधि 3: मैन्युअल चरण

यदि उपरोक्त make विधि काम नहीं करती है, या यदि आप अधिक नियंत्रण चाहते हैं, तो आपको मैन्युअल रूप से आगे बढ़ना पड़ सकता है।

चरण 1: बाइनरी टेम्पलेट फ़ाइलों को C++ कोड में संकलित करना

बाइनरी टेम्पलेट को C++ कोड में संकलित करने के लिए ffcompile कंपाइलर चलाएँ। यह दो तर्क लेता है: .bt बाइनरी टेम्पलेट, और एक .cpp C++ फ़ाइल जो उत्पन्न होनी है।

./ffcompile templates/gif.bt gif.cpp

चरण 2: C++ कोड संकलित करना

एक फ़ज़र gif-fuzzer बनाने के लिए निम्नलिखित कमांड का उपयोग करें। पहले, सामान्य कमांड-लाइन ड्राइवर संकलित करें:

g++ -c -I . -std=c++17 -g -O3 -Wall fuzzer.cpp

(-I . bt.h फ़ाइल का स्थान दर्शाता है; -std=c++17 C++ मानक सेट करता है।)

फिर, बाइनरी पार्सर/कंपाइलर संकलित करें:

g++ -c -I . -std=c++17 -g -O3 -Wall gif.cpp

अंत में, बाइनरी पार्सर/कंपाइलर को कमांड-लाइन ड्राइवर से लिंक करके एक निष्पादनीय प्राप्त करें। यदि आप किसी अतिरिक्त लाइब्रेरी (जैसे -lz) का उपयोग करते हैं, तो उन्हें यहाँ भी निर्दिष्ट करना सुनिश्चित करें।

g++ -O3 gif.o fuzzer.o -o gif-fuzzer -lz

फ़ज़र चलाना

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

उत्पन्न फ़ज़र पहले तर्क के रूप में एक कमांड लेता है, उसके बाद उस कमांड के विकल्प और तर्क होते हैं।

सबसे महत्वपूर्ण कमांड fuzz है, जो आउटपुट उत्पन्न करने के लिए है। इसके तर्क उपयुक्त प्रारूप में उत्पन्न की जाने वाली फ़ाइलें हैं।

जनरेटर को इस प्रकार चलाएँ:

./gif-fuzzer fuzz output.gif

एक यादृच्छिक बाइनरी फ़ाइल output.gif बनाने के लिए, या:

./gif-fuzzer fuzz out1.gif out2.gif out3.gif

तीन GIF फ़ाइलें out1.gif, out2.gif, और out3.gif बनाने के लिए।

ध्यान दें कि हमने जो gif.bt टेम्पलेट प्रदान किया है, उसे वैध फ़ाइलों का निर्माण आसान बनाने के लिए विशेष कार्यों के साथ बढ़ाया गया है। यदि आप बिना अनुकूलन के मूल .bt टेम्पलेट फ़ाइलों का उपयोग करते हैं, तो आपको निर्माण के दौरान चेतावनियाँ मिल सकती हैं और अमान्य फ़ाइलें बन सकती हैं।

पार्सर चलाना

आप parse कमांड का उपयोग करके फ़ज़र को बाइनरी फ़ाइलों के पार्सर के रूप में भी चला सकते हैं। यह उपयोगी है यदि आप बाइनरी टेम्पलेट की सटीकता का परीक्षण करना चाहते हैं, या यदि आप किसी इनपुट को म्यूटेट करना चाहते हैं (नीचे 'निर्णय फ़ाइलें' देखें)।

पार्सर चलाने के लिए, उपयोग करें:

./gif-fuzzer parse input.gif

यदि input.gif को सफलतापूर्वक पार्स नहीं किया जा सकता है, तो आपको त्रुटि संदेश दिखाई देंगे।

निर्णय फ़ाइलें

पार्सिंग के दौरान, आप सभी पार्सिंग निर्णयों (अर्थात् कौन से पार्सिंग विकल्प चुने गए) को एक निर्णय फ़ाइल में भी संग्रहीत कर सकते हैं। यह लिए गए निर्णयों को गिनाने वाले बाइट्स का एक अनुक्रम है। प्रत्येक बाइट एक एकल पार्सिंग निर्णय को दर्शाता है। बाइट मान 0 का अर्थ है कि पहला विकल्प चुना गया, बाइट मान 1 का अर्थ है कि दूसरा विकल्प चुना गया, और इसी प्रकार आगे।

आप किसी इनपुट को पार्स करते समय ऐसी निर्णय फ़ाइल उत्पन्न कर सकते हैं:

./gif-fuzzer parse --decisions input.dec input.gif

यहाँ, input.dec input.gif को पार्स करने के लिए किए गए निर्णयों को संग्रहीत करता है।

आप इनपुट उत्पन्न करते समय भी ऐसी निर्णय फ़ाइल का उपयोग कर सकते हैं। फ़ज़र तब पार्सिंग के दौरान पाए गए समान निर्णय लेगा। निम्नलिखित कमांड input.gif को पार्स करते समय निर्धारित निर्णयों का उपयोग करके एक नई GIF फ़ाइल उत्पन्न करता है:

./gif-fuzzer fuzz --decisions input.dec input2.gif

यदि सब कुछ ठीक काम करता है, तो दोनों फ़ाइलें समान होनी चाहिए:

cmp input.gif input2.gif

एक निर्णय फ़ाइल को म्यूटेट करके (जैसे, व्यक्तिगत बाइट्स को बदलकर), आप ऐसे इनपुट बना सकते हैं जो पार्स की गई मूल फ़ाइल के समान हों। यह विशिष्ट परीक्षण रणनीतियों और AFL जैसे फ़ज़रों के साथ इंटरफेस करने के लिए उपयोगी है, जहाँ आप gif-fuzzer और इसी तरह के फ़ज़रों का उपयोग निर्णय फ़ाइलों से बाइनरी फ़ाइलों और वापस अनुवादक के रूप में कर सकते हैं: AFL निर्णय फ़ाइलों को म्यूटेट करेगा, और परीक्षण के अंतर्गत प्रोग्राम अनुवादित बाइनरी फ़ाइलों पर चलेगा। बाइनरी फ़ाइलों को सीधे म्यूटेट करने (जैसा कि AFL सामान्यतः करेगा) के विपरीत, इसका लाभ यह होगा कि हमेशा मान्य इनपुट होंगे - और इस प्रकार कवरेज की ओर बहुत तेज़ी से प्रगति होगी।

AFL++ एकीकरण

gif-fuzzer जैसे प्रारूप-विशिष्ट फ़ज़रों के अलावा, FormatFuzzer को gif.so जैसी प्रारूप-विशिष्ट साझा लाइब्रेरीज़ में भी संकलित किया जा सकता है (इसके लिए, बस ./build.sh gif या make gif.so चलाएँ)। उन साझा लाइब्रेरीज़ को AFL++ जैसे सामान्य-उद्देश्यीय फ़ज़र द्वारा लोड किया जा सकता है।

AFL++ को FormatFuzzer के साथ चलाने के लिए, बस हमारे संशोधित AFL++ संस्करण पर दिए गए निर्देशों का पालन करें। हम विभिन्न फ़ज़िंग रणनीतियों का समर्थन करते हैं, जिनमें शामिल हैं:

• AFL+FFMut: AFL++ को FormatFuzzer का उपयोग करके प्रारूप-विशिष्ट स्मार्ट म्यूटेशन प्रदान करने के लिए चलाता है।

• AFL+FFGen: FormatFuzzer को एक प्रारूप-विशिष्ट जनरेटर के रूप में उपयोग करता है, जबकि AFL++ इसके निर्णय बीजों को म्यूटेट करता है।

बाइनरी टेम्पलेट बनाना और अनुकूलित करना

अपने स्वयं के .bt बाइनरी टेम्पलेट लिखने (और इस प्रकार इस प्रारूप के लिए एक उच्च-दक्षता फ़ज़र/पार्सर बनाने) के लिए, 010 संपादक मैनुअल से टेम्पलेट और स्क्रिप्ट्स का परिचय अनुभाग पढ़ें।

कई मामलों में, आप जिस प्रारूप की तलाश कर रहे हैं (या उसके समान) का एक टेम्पलेट पहले से मौजूद हो सकता है। 010 संपादक बाइनरी टेम्पलेट संग्रह पर एक नज़र डालें कि क्या ऐसा कुछ है जिसका आप उपयोग कर सकते हैं या अपने प्रारूप को आधार बना सकते हैं।

ध्यान दें कि रिपॉजिटरी में प्रदान की गई .bt फ़ाइलें आम तौर पर फ़ाइलों को पार्स करने के लिए लक्षित होती हैं। उनका उपयोग फ़ाइलों को उत्पन्न करने के लिए भी किया जा सकता है; लेकिन उनमें अक्सर इस बारे में सटीक जानकारी का अभाव होता है कि इनपुट के कौन से भाग आवश्यक हैं।

इस अनुभाग में, हम उन कुछ तरीकों पर चर्चा करते हैं जिनसे आप .bt फ़ाइलों को FormatFuzzer के साथ अच्छी तरह से काम करने के लिए अनुकूलित कर सकते हैं।

उदाहरण के लिए, GIF प्रारूप के लिए, फ़ाइल templates/gif-orig.bt मूल बाइनरी टेम्पलेट दिखाती है, जो केवल पार्सिंग के लिए डिज़ाइन किया गया था, जबकि फ़ाइल templates/gif.bt एक संशोधित संस्करण है जो वैध GIF उत्पन्न करने में सक्षम है। दोनों फ़ाइलों की तुलना करने पर, हम देखते हैं कि इसे प्राप्त करने के लिए बहुत कम संख्या में परिवर्तनों की आवश्यकता थी।

यदि आपने make gif-fuzzer चलाकर या ffcompile टूल का उपयोग करके एक gif-fuzzer बनाया है, तो आप पहले से ही एक C++ फ़ाइल gif.cpp प्राप्त कर चुके हैं जिसमें GIF जनरेटर और पार्सर का कार्यान्वयन शामिल है। यह देखने के लिए उपयोगी है कि आप बाइनरी टेम्पलेट में जो परिवर्तन करते हैं, वे निष्पादन योग्य कोड में कैसे अनुवादित होते हैं। C++ कोड पर अधिक विवरण अगले अनुभाग में प्रस्तुत किए गए हैं।

GIF बाइनरी टेम्पलेट वास्तव में उन्हें स्ट्रक्ट फ़ील्ड में पार्स करने से पहले फ़ाइल में अगले बाइट्स के मानों को आगे देखने के लिए लुकहेड फ़ंक्शन ReadUByte() और ReadUShort() का उपयोग करता है। निर्माण के समय, हम उन फ़ंक्शनों को एक अतिरिक्त तर्क प्राप्त करने की अनुमति देते हैं जो उन बाइट्स के लिए चुनने के लिए अच्छे ज्ञात मानों का एक सेट निर्दिष्ट करता है जिन्हें हम आगे देखते हैं। इसके अलावा, हम किसी विशेष लुकहेड फ़ंक्शन, जैसे ReadUByte(), को कॉल करते समय हमेशा उपयोग करने के लिए अच्छे ज्ञात मानों का एक वैश्विक सेट निर्दिष्ट करने की भी अनुमति देते हैं। वे ReadUByteInitValues वेक्टर में संग्रहीत होते हैं।

डिफ़ॉल्ट रूप से, हमारी अनुवाद प्रक्रिया ffcompile उन दिलचस्प मानों को खोजने का प्रयास करती है जिनका उपयोग लुकहेड बाइट्स के विरुद्ध तुलनाओं में किया गया है और उन्हें ज्ञात मानों के वैश्विक सेट के रूप में उपयोग करती है। जब चलाते हैं:

./ffcompile templates/gif.bt gif.cpp

एक मुद्रित संदेश पहचाने गए लुकहेड फ़ंक्शनों के साथ-साथ खनन किए गए दिलचस्प मानों को दिखाता है:

Finished creating cpp generator.

Lookahead functions found:

ReadUByte
ReadUShort

Mined interesting values:

GlobalColorTableFlag: ['1']
LocalColorTableFlag: ['1']
ReadUByte: ['0x3B', '0x2C']
ReadUShort: ['0xF921', '0xFE21', '0x0121', '0xFF21']
Signature: ['"GIF"']

हालाँकि, GIF निर्माण के लिए, फ़ंक्शन के प्रत्येक कॉल पर ReadUByte() के लिए अच्छे ज्ञात मानों का सेट व्यक्तिगत रूप से निर्दिष्ट करना बेहतर है। इसलिए हम एक खाली सरणी (आकार 0) परिभाषित करते हैं:

const local UBYTE ReadUByteInitValues[0];

वैश्विक ReadUByteInitValues के सेट को ओवरराइट करने के लिए और ReadUByte() के प्रत्येक कॉल के लिए, हम उस विशेष स्थान के लिए उपयोग करने के लिए अच्छे मानों का सेट निर्दिष्ट करने के लिए एक अतिरिक्त तर्क का उपयोग करते हैं। बाइनरी टेम्पलेट भाषा रनटाइम स्थितियों के आधार पर इस विकल्प को बनाने की अनुमति देने के लिए पर्याप्त शक्तिशाली है। उदाहरण के लिए, निम्नलिखित कोड में हम दिखाते हैं कि कैसे ReadUByte() कॉल के लिए उपयुक्त मानों का चुनाव वर्तमान GIF संस्करण पर निर्भर हो सकता है जिसे हम उत्पन्न कर रहे हैं। GIF संस्करण 89a बाइट (0x21) के लिए एक अतिरिक्त संभावित मान की अनुमति देता है।

	if(GifHeader.Version == "89a")
		local UBYTE values[] = { 0x3B, 0x2C, 0x21 };
	else
		local UBYTE values[] = { 0x3B, 0x2C };

	while (ReadUByte(FTell(), values) != 0x3B) {
		...
	}

GIF बाइनरी टेम्पलेट के लिए शेष संपादन समान हैं। उदाहरण के लिए, प्रत्येक स्ट्रक्ट फ़ील्ड के लिए ज्ञात अच्छे मानों का एक सेट भी निर्दिष्ट किया जा सकता है। उदाहरण के लिए, यह Version फ़ील्ड के लिए सही मान निर्दिष्ट करता है: 87a और 89a।

	char	Version[3] = { {"87a"}, {"89a"} };

उत्पन्न C++ कोड को समझना

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

C++ कोड बाइनरी टेम्पलेट में परिभाषित प्रत्येक struct और union के लिए, साथ ही int जैसे नेटिव प्रकारों के लिए एक क्लास बनाता है।

निर्माण के समय, जब एक चर को आरंभ किया जाता है, तो हम अच्छे ज्ञात मानों का एक सेट परिभाषित कर सकते हैं जो यह चर ग्रहण कर सकता है। उदाहरण के लिए, कंस्ट्रक्टर कॉल:

char_array_class cname(cname_element, { "IHDR", "tEXt", "PLTE", "cHRM", "sRGB", "iEXt", "zEXt", "tIME", "pHYs", "bKGD", "sBIT", "sPLT", "acTL", "fcTL", "fdAT", "IHDR", "IEND" });

चर cname के लिए 17 अच्छे मान निर्दिष्ट करेगा। लेकिन यह अक्सर पर्याप्त नहीं होता है, क्योंकि उपयुक्त चंक प्रकारों का चुनाव संदर्भ-संवेदनशील होता है। इसलिए हम एक नया चंक उत्पन्न करते समय निर्माण के समय अच्छे मानों का एक सेट निर्दिष्ट करने की भी अनुमति देते हैं। उदाहरण के लिए, इस कॉल का उपयोग पहले चंक के लिए chunk का एक इंस्टेंस उत्पन्न करने के लिए किया जा सकता है, जिसका प्रकार IHDR होना चाहिए।

GENERATE(chunk, ::g->chunk.generate({ "IHDR" }, false));

दूसरा चंक उत्पन्न करते समय, हम उन संभावित चंकों की इस लंबी सूची का उपयोग कर सकते हैं जो IHDR चंक और PLTE चंक के बीच आ सकते हैं:

GENERATE(chunk, ::g->chunk.generate({ "iCCP", "sRGB", "sBIT", "gAMA", "cHRM", "pHYs", "sPLT", "tIME", "zTXt", "tEXt", "iTXt", "eXIf", "oFFs", "pCAL", "sCAL", "acTL", "fcTL", "fdAT", "fRAc", "gIFg", "gIFt", "gIFx", "sTER" }, true));

जनरेटर फिर नए इंस्टेंस के लिए उपयोग करने के लिए ज्ञात अच्छे मानों में से एक को समान रूप से चुनेगा। हम छोटी संभावना 1/128 के साथ एक बुरा मान चुनने की भी अनुमति देते हैं जो ज्ञात अच्छे मानों में से एक नहीं है। इस सुविधा को किसी भी समय set_evil_bit विधि का उपयोग करके सक्षम या अक्षम किया जा सकता है।

जनरेटर द्वारा लिए गए सभी यादृच्छिक विकल्प rand_int() विधि को कॉल करके किए जाते हैं।

long long rand_int(unsigned long long x, std::function<long long (unsigned char*)> parse);

जब प्रोग्राम जनरेटर के रूप में चल रहा होता है, तो यह विधि रैंडम बफर से बाइट्स पढ़कर 0 से x-1 तक एक पूर्णांक का नमूना लेती है। जब प्रोग्राम पार्सर के रूप में चल रहा होता है, तो यह विधि यह पता लगाने के लिए parse() फ़ंक्शन का उपयोग करती है कि लक्ष्य फ़ाइल उत्पन्न करने के लिए रैंडम बफर में कौन से यादृच्छिक बाइट्स मौजूद होने चाहिए, और फिर उन बाइट्स को रैंडम बफर में लिखती है। parse फ़ंक्शन एक तर्क के रूप में फ़ाइल की वर्तमान स्थिति पर बफर प्राप्त करता है और फिर वापस लौटना चाहिए कि इस सटीक फ़ाइल कॉन्फ़िगरेशन को उत्पन्न करने के लिए rand_int() के वर्तमान कॉल द्वारा कौन सा मान लौटाया जाना चाहिए।

लेखक

FormatFuzzer को Rafael Dutra <[email protected]> द्वारा डिज़ाइन और लिखा गया था।

फ़ज़र कंपाइलर की अवधारणा Rahul Gopinath <[email protected]> और Andreas Zeller <[email protected]> द्वारा प्रस्तुत की गई थी।

कॉपीराइट और लाइसेंस

FormatFuzzer का कॉपीराइट © 2020, 2021 CISPA हेल्महोल्ट्ज़ सेंटर फॉर इंफॉर्मेशन सिक्योरिटी द्वारा है। निम्नलिखित लाइसेंस लागू होते हैं:

• FormatFuzzer कोड (विशेष रूप से, सभी C++ कोड और इसके निर्माण से संबंधित कोड) GNU GENERAL PUBLIC LICENSE के अधीन है, जैसा कि COPYING में पाया गया है।

• उपरोक्त के अपवाद के रूप में, FormatFuzzer द्वारा उत्पन्न C++ कोड (अर्थात्, विशिष्ट प्रारूपों के लिए फ़ज़र और पार्सर) सार्वजनिक डोमेन में हैं।

• मूल pfp कोड, जिस पर FormatFuzzer आधारित है, MIT लाइसेंस के अधीन है, जैसा कि LICENSE-pfp में पाया गया है।