jdam - संरचना-जागरूक JSON फ़ज़िंग

jdam एक Radamsa से प्रेरित उपकरण है जो मनमाने JSON ऑब्जेक्ट्स को संरचना-जागरूक तरीके से फ़ज़ करता है, जो सुनिश्चित करता है कि फ़ज़िंग परिणाम हमेशा मान्य JSON हों।

कई मौजूदा फ़ज़िंग उपकरण इनपुट को आँख मूंदकर बदल देंगे और अक्सर परिणाम को अमान्य JSON कर देंगे। इसका मतलब है कि फ़ज़ परीक्षण केवल लक्ष्य एप्लिकेशन के JSON पार्सर का परीक्षण करेगा और फ़ज़ परीक्षण कभी भी अंतर्निहित एप्लिकेशन कोड तक नहीं पहुँचेगा क्योंकि अनुरोध अमान्य हैं। Jdam इस समस्या को हल करने का एक प्रयास है।

jdam कई म्यूटेशन मॉड्यूल के साथ आता है जो सभी का उद्देश्य फ़ज़ किए गए डेटा को प्रोसेस करने वाले सिस्टम में संभावित समस्याओं और कमजोरियों का पता लगाना है।

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

• SQL Injection
• Command Injection
• LDAP Injection
• NoSQL Injection
• Format String Injection
• Local File Inclusion
• Integer Overflow
• और अधिक

उपलब्ध म्यूटेटरों की पूरी सूची देखने के लिए, jdam -list का उपयोग करें।

नोट

jdam अभी भी काफी कच्चा है और त्रुटियों की उम्मीद की जानी चाहिए। हालांकि यह साहसी लोगों के लिए रिलीज़ करने के लिए पर्याप्त स्थिर है, लेकिन इसे अभी के लिए अल्फ़ा सॉफ़्टवेयर मानें!

स्थापना

अपने ऑपरेटिंग सिस्टम के लिए पहले से निर्मित release डाउनलोड करें या रिपॉजिटरी को क्लोन करें और go build -o jdam cmd/jdam/* के साथ संकलन करें।

उपयोग

Usage of jdam:
  -count int
    	Number of fuzzed objects to generate (default 1)
  -ignore string
    	Comma-separated list of fields to exclude from fuzzing
  -list
    	List available mutators
  -max-depth int
    	Maximum object depth to fuzz (default 100)
  -mutators string
    	Comma-separated list of mutator IDs to use (default: all)
  -nil-chance float
    	Probability of value being set to nil (between 0 (no nils) and 1 (all nils)) (default 0.75)
  -output string
    	Output file pattern to use for results (e.g. /tmp/jdam-%d.json)
  -rounds int
    	Number of times to fuzz object (default 1)
  -seed int
    	Seed to use for pseudo-random number generator (default: current UNIX timestamp)
  -verbose
    	Print activity information
  -version
    	Print current jdam version

jdam एक मान्य JSON ऑब्जेक्ट ({...}) को इसमें पाइप करके काम करता है। डिफ़ॉल्ट रूप से, jdam एक यादृच्छिक फ़ील्ड पर एक यादृच्छिक क्रमपरिवर्तन करेगा और परिणामी JSON ऑब्जेक्ट प्रिंट करेगा:

$ echo '{"hello":"world"}' | jdam
{"hello":{"id":1}}

विषय JSON को -rounds फ़्लैग के साथ कई बार म्यूटेट किया जा सकता है, लेकिन ध्यान रखें कि पिछले फ़ज़ पेलोड भी म्यूटेट हो सकते हैं:

$ echo '{"hello":"world"}' | jdam -rounds 10
{"hello":{"_constructor":"${42*444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444442}"}}

एकाधिक फ़ज़ किए गए ऑब्जेक्ट -count फ़्लैग के साथ उत्पन्न किए जा सकते हैं:

$ echo '{"hello":"world"}' | jdam -count 10
{"hello":"sorld"}
{"hello":"../../../../../../../../../../../../../../../../../../../../etc/passwd"}
{"hello":"{{42*42}}"}
{"hello":null}
{"hello":"' \u0026\u0026 this.password.match(/.*/)//+\u0000"}
{"hello":{"$where":"1"}}
{"hello":"null"}
{"hello":"\";touch /tmp/jdam.70797.fail'"}
{"hello":null}
{"hello":"|| 1==1"}

परिणामों को फ़ाइलों में लिखना

jdam फ़ज़िंग परिणामों को अलग-अलग फ़ाइलों में लिख सकता है यदि आप कमांड के STDOUT का उपयोग करने के बजाय परीक्षण फ़ाइलें तैयार करना चाहते हैं:

$ echo '{"hello":"world"}' | jdam -count 10 -output "/tmp/jdam-%d.json"

उपरोक्त कमांड /tmp में jdam-1.json से jdam-10.json तक 10 फ़ाइलें उत्पन्न करेगा। विशेष %d क्रिया को स्वचालित रूप से एक अनुक्रमिक संख्या से बदल दिया जाएगा ताकि परिणाम अलग-अलग फ़ाइलों में लिखे जा सकें।

फ़ील्ड को अनदेखा करना

यदि आप सुनिश्चित करना चाहते हैं कि jdam विषय JSON ऑब्जेक्ट में विशिष्ट फ़ील्ड को कभी म्यूटेट न करे, तो आप jdam को -ignore फ़्लैग के साथ उन्हें अनदेखा करने का निर्देश दे सकते हैं:

$ echo '{"id":13,"articleId":37,"comment":"Hello"}' | ./jdam -count 10 -ignore id,articleId
{"id":13,"articleId":37,"comment":"%x%x%x%x"}
{"id":13,"articleId":37,"comment":"search=')] | //user/*[contains(*,'"}
{"id":13,"articleId":37,"comment":"' and count(/comment())=1 and '1'='1"}
{"id":13,"articleId":37,"comment":"\u0016ello"}
{"id":13,"articleId":37,"comment":"/"}
{"id":13,"articleId":37,"comment":null}
{"id":13,"articleId":37,"comment":"{{{42*42}}}"}
{"id":13,"articleId":37,"comment":"@*"}
{"id":13,"articleId":37,"comment":"Helloooooooooooooooo"}
{"id":13,"articleId":37,"comment":"//*"}

Ffuf के साथ jdam का उपयोग करना

ffuf एक शानदार वेब फ़ज़र है और jdam को आसानी से फ़ज़िंग के लिए इनपुट के रूप में उपयोग किया जा सकता है:

ffuf -input-cmd 'cat subject.json | jdam -rounds 3' -d FUZZ -u http://localhost/api/todos/1 -X PUT -v -mc 500 -mr 'error|failed|failure|fault|abort|root:|1764|0x|\d{20}' -od /tmp/ffuf_test

उपरोक्त कमांड ffuf को निर्देश देगा कि वह jdam से अपना फ़ज़िंग इनपुट प्राप्त करे और इसे PUT /api/todos/1 पर अनुरोध निकाय के रूप में भेजे। अनुरोध और प्रतिक्रिया विवरण tmp/ffuf_test/ पर लिखे जाएंगे यदि प्रतिक्रिया 500 Internal Server Error है या प्रतिक्रिया निकाय में कुछ दिलचस्प स्ट्रिंग्स हैं।

पैकेज के रूप में jdam का उपयोग करना

यदि आप Go जानते हैं और अत्यधिक विशिष्ट फ़ज़िंग की आवश्यकता है, तो आप अपने स्वयं के Go कोड में jdam का उपयोग कर सकते हैं। उपयोग के उदाहरणों के लिए examples/ फ़ोल्डर देखें।

क्या देखना है

फ़ज़िंग तभी उपयोगी है जब आप पता लगा सकें कि किसी विशेष म्यूटेशन ने कोई समस्या उत्पन्न की या कोई कमजोरी ट्रिगर की। ये संकेत लक्ष्य प्रणाली और वातावरण के आधार पर भिन्न होंगे, लेकिन यहाँ कुछ सामान्य चीज़ें दी गई हैं जिन पर ध्यान देना चाहिए:

1. क्रैश: यदि लक्ष्य प्रणाली अब कनेक्शन स्वीकार नहीं कर रही है, तो इस बात की अच्छी संभावना है कि यह किसी प्रकार के मेमोरी भ्रष्टाचार बग के कारण क्रैश हुआ। अंतिम अनुरोध को पुन: चलाएँ और देखें कि क्या क्रैश को पुन: उत्पन्न किया जा सकता है।
2. असामान्य रूप से धीमी प्रतिक्रियाएँ: यदि कोई अनुरोध सर्वर को असामान्य रूप से धीमी प्रतिक्रिया देने का कारण बनता है, तो इस बात की अच्छी संभावना है कि किसी पेलोड ने अंतर्निहित सिस्टम के लिए समस्याएँ उत्पन्न कीं या डेटाबेस को sleep करने का निर्देश दिया।
3. असामान्य रूप से बड़ी प्रतिक्रियाएँ: यदि कोई प्रतिक्रिया औसत की तुलना में असामान्य रूप से बड़ी है, तो इसमें दिलचस्प डेटा हो सकता है जिसे वापस करने का इरादा नहीं था।
4. 500 Internal Server Error और अन्य त्रुटि प्रतिक्रियाएँ: ये आमतौर पर तब होती हैं जब किसी पेलोड ने एप्लिकेशन में एक अप्रत्याशित या अप्रबंधित त्रुटि ट्रिगर की।
5. त्रुटि और विफलता कीवर्ड: ऐसी प्रतिक्रियाएँ जिनमें error, failure, failed आदि जैसे त्रुटि-संबंधित कीवर्ड हों।
6. /etc/passwd फ़ाइल सामग्री: सभी स्थानीय फ़ाइल समावेशन पेलोड पूर्वानुमानित सामग्री रखने के लिए /etc/passwd फ़ाइल को शामिल करने का प्रयास करते हैं। इसलिए root: युक्त कोई भी प्रतिक्रिया बहुत दिलचस्प है!
7. जादुई संख्या 1764: सभी टेम्पलेट इंजेक्शन पेलोड कमजोर टेम्पलेटिंग इंजनों को 42*42 का मूल्यांकन करने का प्रयास करेंगे जो 1.764 के बराबर होता है। यदि यह संख्या कभी प्रतिक्रिया में आती है, तो उच्च संभावना है कि सिस्टम टेम्पलेट इंजेक्शन के प्रति संवेदनशील है।
8. 0x और लंबी संख्याएँ: यदि प्रतिक्रिया में 0x के बाद एक लंबी हेक्स स्ट्रिंग या लंबी संख्यात्मक स्ट्रिंग होती है, तो यह संकेत हो सकता है कि किसी पेलोड ने फ़ॉर्मेट स्ट्रिंग कमजोरी को ट्रिगर किया।

ट्रॉफी रूम

jdam अभी भी एक बहुत ही नया उपकरण है इसलिए इसने अभी तक कोई अच्छी बग का पता नहीं लगाया है। अगर jdam ने आपको CVE या अच्छा बग बाउंटी प्राप्त करने में मदद की है तो मुझे आपसे सुनकर बहुत खुशी होगी और मैं यहाँ आपकी राइट-अप या रिपोर्ट से लिंक करूंगा। :)

श्रेय

मैं कुछ अन्य परियोजनाओं को श्रेय और धन्यवाद देना चाहूंगा:

• Radamsa for the inspiration for jdam.
• gofuzz for giving me ideas on how to code jdam.
• SecLists and PayloadsAllTheThings for fuzzing payloads.
• ffuf for making it super easy to use jdam against web apps.

शुभ फ़ज़िंग!