
वितरित, कोड-कवरेज निर्देशित स्नैपशॉट-आधारित फ़ज़र जो विंडोज और लिनक्स पर उपयोगकर्ता और कर्नेल-मोड लक्ष्यों के लिए है, जिसमें एमुलेटर और हाइपरवाइज़र बैकएंड शामिल हैं।
<div align='center'>
<h1><code>what the fuzz</code></h1>
<p>
<strong>एक वितरित, कोड-कवरेज निर्देशित, क्रॉस-प्लेटफ़ॉर्म स्नैपशॉट-आधारित फज़र जो Microsoft Windows और Linux यूज़र-मोड (प्रायोगिक!) पर चलने वाले यूज़र और/या कर्नेल-मोड लक्ष्यों पर हमला करने के लिए डिज़ाइन किया गया है।</strong>
</p>
<p>
<img src="https://github.com/0vercl0k/wtf/actions/workflows/wtf.yml/badge.svg?branch=main"/>
</p>
<p>
<img src="https://assets.kitploit.com/production/public/readmes/4699/b59a1b82269282cf1d3643911853b5e4ab2cab6094382372fcac1fd0689b0ab0.webp"/>
</p>
</div>
## अवलोकन
**what the fuzz** या **wtf** एक वितरित, कोड-कवरेज निर्देशित, अनुकूलन योग्य, क्रॉस-प्लेटफ़ॉर्म स्नैपशॉट-आधारित फज़र है जो Microsoft Windows या Linux (**प्रायोगिक**, [linux_mode](https://github.com/0vercl0k/wtf/blob/main/linux_mode) देखें) पर चलने वाले यूज़र और/या कर्नेल-मोड लक्ष्यों पर हमला करने के लिए डिज़ाइन किया गया है। लक्ष्य का निष्पादन [bochscpu](https://github.com/yrp604/bochscpu) के साथ एक एमुलेटर के अंदर (धीमा, सबसे सटीक), [Windows Hypervisor Platform APIs](https://docs.microsoft.com/en-us/virtualization/api/hypervisor-platform/hypervisor-platform) के साथ Windows VM के अंदर, या [KVM APIs](https://www.kernel.org/doc/html/latest/virt/kvm/api.html) के साथ Linux VM के अंदर (सबसे तेज़) किया जा सकता है।
इसने सॉफ़्टवेयर की एक विस्तृत श्रृंखला में मेमोरी भ्रष्टाचार भेद्यताओं का पता लगाया: [IDA Pro](https://github.com/0vercl0k/fuzzing-ida75), एक लोकप्रिय [AAA गेम](https://blog.ret2.io/2021/07/21/wtf-snapshot-fuzzing/), [Windows कर्नेल](https://microsoft.fandom.com/wiki/Architecture_of_Windows_NT), [Microsoft RDP क्लाइंट](https://www.hexacon.fr/slides/Hexacon2022-Fuzzing_RDPEGFX_with_wtf.pdf), [NVIDIA GPU डिस्प्ले ड्राइवर](https://nvidia.custhelp.com/app/answers/detail/a_id/5383), आदि।
संकलित बाइनरीज़ [CI आर्टिफैक्ट्स](https://github.com/0vercl0k/wtf/actions/workflows/wtf.yml) या [रिलीज़](https://github.com/0vercl0k/wtf/releases) अनुभाग से Windows और Linux दोनों के लिए उपलब्ध हैं।
यदि आप इसके इतिहास के बारे में अधिक पढ़ना चाहते हैं या इसे वास्तविक लक्ष्य पर कैसे उपयोग करें, तो मैं शुरू करने के लिए इन पोस्टों को देखने की सलाह देता हूं 🔥
- [एक नया स्नैपशॉट फज़र बनाना और IDA को फज़ करना](https://doar-e.github.io/blog/2021/07/15/building-a-new-snapshot-fuzzer-fuzzing-ida/)
- [स्नैपशॉट-आधारित फज़र्स के साथ आधुनिक UDP गेम प्रोटोकॉल को फज़ करना](https://blog.ret2.io/2021/07/21/wtf-snapshot-fuzzing/) by [Markus Gaasedelen](https://twitter.com/gaasedelen)
- ["what the fuzz" के साथ RDPEGFX को फज़ करना](https://thalium.github.io/blog/posts/rdpegfx/) by [Colas Le Guernic](https://github.com/clslgrnc), Jérémy Rubert, and Anonymous
- [नेटवर्क प्रोटोकॉल फज़िंग की एक यात्रा – Microsoft IMAP क्लाइंट प्रोटोकॉल का विच्छेदन](https://www.fortinet.com/blog/threat-research/analyzing-microsoft-imap-client-protocol) by [Wayne Chin Yick Low](https://www.fortinet.com/blog/search?author=Wayne+Chin+Yick+Low)
- [Trail Of Bits के टेस्टिंग हैंडबुक का स्नैपशॉट फज़िंग अनुभाग](https://appsec.guide/docs/fuzzing/snapshot-fuzzing/)
- [EDRs पर हमला भाग 4: डिफ़ेंडर के स्कैनिंग और एमुलेशन इंजन (mpengine.dll) को फज़ करना](https://labs.infoguard.ch/posts/attacking_edr_part4_fuzzing_defender_scanning_and_emulation_engine/) by [Manuel Feifel](https://x.com/p0w1_)
## उपयोग
सुविधाओं को आज़माने का सबसे अच्छा तरीका [fuzzer_hevd](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_hevd.cc) / [fuzzer_tlv_server](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_tlv_server.cc) मॉड्यूल के साथ काम करना है। आप [target-hevd.7z](https://github.com/0vercl0k/wtf/releases) / [target-tlv_server.7z](https://github.com/0vercl0k/wtf/releases) आर्काइव को प्राप्त कर सकते हैं और उन्हें `targets/` निर्देशिका में निकाल सकते हैं। आर्काइव में प्रत्येक लक्ष्य के लिए अपेक्षित निर्देशिका ट्री होते हैं:
- `inputs` वह फ़ोल्डर है जहां आपके इनपुट टेस्ट-केस जाते हैं,
- `outputs` वह फ़ोल्डर है जहां वर्तमान मिनसेट फ़ाइलें सहेजी जाती हैं,
- `coverage` वह फ़ोल्डर है जहां `.cov` फ़ाइलें होने की अपेक्षा की जाती है,
- `crashes` वहां है जहां क्रैश सहेजे जाते हैं,
- `state` वहां है जहां मेमोरी डंप (`mem.dmp`) के साथ-साथ CPU स्थिति (`regs.json`) और सिंबल स्टोर (`symbol-store.json`) संग्रहीत किए जाते हैं। सिंबल स्टोर एक सरल JSON फ़ाइल है जिसका उपयोग Linux सिस्टम पर यह जानने के लिए किया जाता है कि ब्रेकपॉइंट कहां रखें, क्योंकि उन प्लेटफार्मों पर सिंबल / dbgeng के लिए कोई समर्थन नहीं है। **wtf** इस फ़ाइल को रनटाइम पर उत्पन्न करता है जब भी आप Windows पर अपना लक्ष्य चलाते हैं।
निम्नलिखित यह मानता है कि आपने नवीनतम रिलीज़ से जुड़ी [target-hevd.7z](https://github.com/0vercl0k/wtf/releases) फ़ाइल डाउनलोड की है, और इसे **wtf** के आपके क्लोन की `targets` निर्देशिका में निकाला है। आपके पास `wtf/targets/hevd` होना चाहिए जिसमें आपको `inputs` / `outputs` आदि निर्देशिकाएं मिलेंगी।
### सर्वर नोड प्रारंभ करना
सर्वर मूल रूप से मस्तिष्क है और सभी स्थिति का ट्रैक रखता है: समग्र कोड-कवरेज, कोर्पस, यह टेस्ट-केस उत्पन्न करता है और उन्हें क्लाइंट को वितरित करता है।
यहां बताया गया है कि आप स्थानीय सर्वर नोड कैसे लॉन्च कर सकते हैं:```text
wtf.exe master --name hevd --max_len=1028 --runs=10000000
```
`max_len` विकल्प उत्पन्न टेस्ट-केस के आकार को सीमित करने के लिए उपयोग किया जाता है, `runs` उत्पन्न होने वाले टेस्ट-केस की संख्या है, `address` निर्दिष्ट करता है कि **wtf** को कहाँ सुनना चाहिए, `target` एक निर्देशिका है जिसमें ऊपर वर्णित निर्देशिका ट्री है (उपयोगकर्ता `--input` / `--output` / `--crashes` के साथ उन निर्देशिकाओं को ओवरराइड करना भी चुन सकता है) और `name` आपके फ़ज़िंग मॉड्यूल का नाम निर्दिष्ट करता है ताकि मास्टर आपके जनरेटर फ़ंक्शन को कॉल कर सके यदि आपने एक परिभाषित किया है।
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/4a03fc75eed3ed5a92f7f10def697dbf220ae36b0701f05b37759eb432fc0fd9.webp">
</p>
### Fuzzing नोड्स
क्लाइंट नोड्स एक टेस्ट-केस चलाते हैं जो सर्वर द्वारा उत्पन्न और वितरित किया गया है और परिणाम सर्वर को वापस भेजते हैं (कोड-कवरेज, परिणाम, आदि)।
इस प्रकार आप एक क्लाइंट नोड शुरू करेंगे जो *bochscpu* बैकएंड का उपयोग करता है:```text
wtf.exe fuzz --name hevd --limit 10000000
```
`fuzz` उप-कमांड का उपयोग `name` विकल्प के साथ किया जाता है ताकि यह निर्दिष्ट किया जा सके कि किस फ़ज़र मॉड्यूल का उपयोग करना है, `backend` निष्पादन बैकएंड निर्दिष्ट करता है और `limit` प्रति टेस्टकेस निष्पादित करने के लिए निर्देशों की अधिकतम संख्या (बैकएंड पर निर्भर करते हुए, इस विकल्प का अलग अर्थ होता है)।
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/3e534c8f6ad3507bfb61307e00957fcbf9b32de3645979be895cccfb5ceb9b26.webp">
</p>
### एक टेस्ट-केस चलाना
यदि आप कोई टेस्ट-केस (या टेस्ट-केसों से भरा फ़ोल्डर) चलाना चाहते हैं, तो आप `run` उप-कमांड का उपयोग कर सकते हैं।
इस प्रकार आप `crash-0xfffff764b91c0000-0x0-0xffffbf84fb10e780-0x2-0x0` टेस्ट-केस चलाएंगे:```
wtf.exe run --name hevd --limit 10000000 --input crashes\crash-0xfffff764b91c0000-0x0-0xffffbf84fb10e780-0x2-0x0
```
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/49b3ca8582d6314724e5615c687472499d5f8f41d04c9543c0a6a070c51f56f8.webp">
</p>
### कॉर्पस को मिनसेट करना
कॉर्पस को मिनसेट करने के लिए, आपको एक सर्वर नोड और जितने आवश्यक हों उतने क्लाइंट नोड्स का उपयोग करना होगा, जैसे आप फ़ज़िंग जॉब के लिए करते हैं। आप बस `runs` विकल्प को 0 पर सेट कर सकते हैं।
इस प्रकार आप `outputs` में कॉर्पस को `minset` निर्देशिका में मिनसेट करेंगे (यह भी दर्शाता है कि आप `inputs` और `outputs` निर्देशिकाओं को कैसे ओवरराइड कर सकते हैं):```
wtf.exe master --name hevd --max_len=1028 --runs=0 --inputs=outputs --outputs=minset
```
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/34e81e9306498c6e47c01a9bd43a4387822c1b2f3ee2baf756b03936ed14edd5.webp">
</p>
### निष्पादन ट्रेस उत्पन्न करना
किसी निष्पादन बैकएंड में अंतर्दृष्टि प्राप्त करने के लिए उपलब्ध मुख्य तंत्र एक निष्पादन ट्रेस उत्पन्न करना है। *bochscpu* ऐसा करने के लिए सबसे तेज़ बैकएंड है, क्योंकि अन्य बैकएंड पर VMX मोड से बाहर निकलना बहुत महंगा होता है।
आप `crash-0xfffff764b91c0000-0x0-0xffffbf84fb10e780-0x2-0x0` टेस्ट-केस के लिए इस प्रकार एक निष्पादन ट्रेस उत्पन्न करेंगे:```
wtf.exe run --name hevd --limit 10000000 --input crashes\crash-0xfffff764b91c0000-0x0-0xffffbf84fb10e780-0x2-0x0 --trace-type=rip
```
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/340b4b251e378eaf21c6f5ffdd4f013bd2cef89f23a604cffd0ebf897d27c71f.webp">
</p>
निष्पादन ट्रेस को प्रतीकीकृत करने के लिए आपको [symbolizer-rs](https://github.com/0vercl0k/symbolizer-rs) का उपयोग करना चाहिए। इस प्रकार आप ऊपर उत्पन्न `crash-0xfffff764b91c0000-0x0-0xffffbf84fb10e780-0x2-0x0.trace` निष्पादन ट्रेस को प्रतीकीकृत करेंगे:```
symbolizer-rs.exe --trace crash-0xfffff764b91c0000-0x0-0xffffbf84fb10e780-0x2-0x0.rip.trace
```
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/fa47b049f74c5726a0b41d0e4cf023b717fec8830b14188e988b87c6dbca8aa1.webp">
</p>
## Tenet ट्रेसेस उत्पन्न करना
यदि आपको अधिक प्रासंगिक जागरूकता की आवश्यकता महसूस होती है, तो *bochscpu* बैकएंड आपको निष्पादन ट्रेसेस उत्पन्न करने की अनुमति देता है जिन्हें [Tenet](https://github.com/gaasedelen/tenet) ट्रेस एक्सप्लोरर में लोड किया जा सकता है। नीचे दिए गए उदाहरण में, मैं `memmove` में एक क्रैश से शुरू करता हूँ और पीछे जाकर पता लगाता हूँ कि स्रोत पॉइंटर कहाँ से आ रहा है (user-mode!):```
wtf.exe run --name hevd --limit 10000000 --input crashes\crash-0xfffff764b91c0000-0x0-0xffffbf84fb10e780-0x2-0x0 --trace-type=tenet
```
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/34df2f5ca8f378db664d3f01bcbefdd43409e300d256d50e3f4f630eb06cc7be.webp">
</p>
### कोड-कवरेज ट्रेस उत्पन्न करना
कोड-कवरेज ट्रेस उत्पन्न करने के लिए आप `--trace-type=cov` विकल्प के साथ `run` उप-कमांड का उपयोग कर सकते हैं।
इस प्रकार आप `minset` फ़ोल्डर के अंदर सभी फ़ाइलों के लिए कोड-कवरेज ट्रेस उत्पन्न कर सकते हैं और उन्हें `coverage-traces` फ़ोल्डर में संग्रहीत कर सकते हैं:```
wtf.exe run --name hevd --input minset --trace-path=coverage-traces --trace-type=cov
```
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/c338442f63a8dd105180ec38f8d3f7ffd5679442b400d5fb14e843ef73658ce3.webp">
</p>
वे ट्रेस सीधे [lighthouse](https://github.com/gaasedelen/lighthouse) में लोड नहीं किए जा सकते क्योंकि वे प्रतीकीकृत नहीं हैं।
यहां बताया गया है कि आप `coverage-traces` फ़ोल्डर के अंदर सभी फ़ाइलों को कैसे प्रतीकीकृत करेंगे और परिणामों को `coverage-traces-symbolized` में लिखेंगे:```
symbolizer-rs.exe --trace coverage-traces -o coverage-traces-symbolized --style modoff
```
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/8a3c3ca18571abef16a9f87f736fe4d52ac102f41095eab4db32533cb5b198b4.webp">
</p>
और अंत में, आप उन्हें [lighthouse](https://github.com/gaasedelen/lighthouse) में लोड कर सकते हैं:
<p align='center'>
<img src="https://assets.kitploit.com/production/public/readmes/4699/35d9c25c3d26abf5761fec9e7848ba09d090c7aab32322a740732d82e85964e8.webp">
</p>
इसके अलावा यदि आप व्यक्तिगत कोड-कवरेज की परवाह नहीं करते हैं, तो मास्टर एक `coverage.cov` फ़ाइल रखता है जिसमें अभ्यास किए गए अद्वितीय समग्र कोड-कवरेज शामिल है। यह फ़ज़िंग कार्य के दौरान वैश्विक कोड-कवरेज को बहुत जल्दी जांचना आसान बनाता है।
## यह कैसे काम करता है?
**wtf** एक *निष्पादन बैकएंड* के माध्यम से उपयोगकर्ता और कर्नेल मोड चलाता है और उपयोगकर्ता पर लक्ष्य में परीक्षण केस डालने के लिए निर्भर करता है। अन्य शास्त्रीय फ़ज़र उपकरणों के विपरीत, **wtf** अधिकांश भारी काम नहीं करता; उपयोगकर्ता करता है। उपयोगकर्ता को हार्नेस्ड लक्ष्य को बहुत अच्छी तरह से जानना होता है और लक्ष्य को ऑनबोर्ड करना एक पुनरावृत्तीय प्रक्रिया है जिसमें समय लगेगा। हालांकि यदि आप हैकिंग शुरू करने के लिए तैयार हैं तो इसमें बहुत लचीलापन है :)
किसी लक्ष्य को हार्नेस करने का सामान्य कार्यप्रवाह निम्नलिखित है:
1. अपने लक्ष्य को एक हाइपर-V वर्चुअल मशीन में चलाएं जो विंडोज चला रही हो, एक वर्चुअल CPU और 4GB RAM के साथ।
1. [KD](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/) का उपयोग करके अपने लक्ष्य को वांछित स्थिति में रखें। उदाहरण के लिए, [HEVD](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver) के IOCTL हैंडलर को लक्षित करने के लिए, मैंने क्लाइंट द्वारा [DeviceIoControl](https://docs.microsoft.com/en-us/windows/win32/api/ioapiset/nf-ioapiset-deviceiocontrol) को लागू करने से ठीक पहले लक्ष्य को उपयोगकर्ता-मोड में रोकना चुना। यह आपके लक्ष्यों के आधार पर अलग-अलग होगा लेकिन आप शायद इसे उस कोड के करीब चाहते हैं जिसे आप फ़ज़ करना चाहते हैं।
```
kd> r
rax=000000dfd98ff3d0 rbx=0000000000000088 rcx=0000000000000088
rdx=00000000deadbeef rsi=0000000000000000 rdi=0000000000000000
rip=00007ff6f5bb111e rsp=000000dfd98ff380 rbp=0000000000000000
r8=000000dfd98ff3d0 r9=0000000000000400 r10=000002263e823055
r11=00007ff6f5bcb54d r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
iopl=0 nv up ei pl nz na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
hevd_client!main+0xae:
00007ff6`f5bb111e ff15dc1e0100 call qword ptr [hevd_client!_imp_DeviceIoControl (00007ff6`f5bc3000)] ds:002b:00007ff6`f5bc3000={KERNEL32!DeviceIoControlImplementation (00007ff8`3e2e6360)}
```
1. [snapshot](https://github.com/0vercl0k/snapshot) का उपयोग करके कर्नेल क्रैश-डंप के साथ-साथ `regs.json` फ़ाइल उत्पन्न करें जिसमें CPU स्थिति होती है। मैं उन फ़ाइलों को अपने `target` निर्देशिका के अंतर्गत एक `state` निर्देशिका में डंप करने की सिफारिश करता हूं (उदाहरण के लिए `targets/hevd/state`):
```
kd> .load c:\work\codes\snapshot\target\release\snapshot.dll
kd> !snapshot -h
[snapshot] Usage: snapshot [OPTIONS] [STATE_PATH]
Arguments:
[STATE_PATH] The path to save the snapshot to
Options:
-k, --kind <KIND> The kind of snapshot to take [default: full] [possible values: active-kernel, full]
-h, --help Print help
kd> !snapshot c:\work\codes\wtf\targets\hevd\state
[snapshot] Dumping the CPU state into c:\work\codes\wtf\targets\hevd\state\regs.json..
[snapshot] Dumping the memory state into c:\work\codes\wtf\targets\hevd\state\mem.dmp..
Creating c:\\work\\codes\\wtf\\targets\\hevd\\state\\mem.dmp - Full memory range dump
0% written.
5% written. 1 min 50 sec remaining.
10% written. 1 min 17 sec remaining.
15% written. 1 min 30 sec remaining.
[...]
Wrote 4.0 GB in 1 min 32 sec.
The average transfer rate was 44.5 MB/s.
Dump successfully written
[snapshot] Done!
```
1. एक [fuzzer module](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_hevd.cc) बनाएं, वह कोड लिखें जो आपके लक्ष्य में [एक परीक्षण-केस डालता है](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_hevd.cc#L20) और [the](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_hevd.cc#L81) [various](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_hevd.cc#L104) [conditions](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_hevd.cc#L115) को [क्रैश का पता लगाने](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_hevd.cc#L115) या [परीक्षण-केस के अंत](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_hevd.cc#L69) के लिए परिभाषित करें।
1. आप [Mutator_t](https://github.com/0vercl0k/wtf/blob/main/src/wtf/mutator.h) इंटरफ़ेस को उपवर्गीकृत करके अपना स्वयं का म्यूटेटर/जनरेटर भी बना सकते हैं। [fuzzer_tlv_server.cc](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_tlv_server.cc) यह समझने के लिए एक अच्छा उदाहरण है कि आप अपना स्वयं का कार्यान्वयन कैसे कर सकते हैं।
इस बिंदु पर आपको पुनरावृत्ति शुरू करनी चाहिए और सत्यापित करना चाहिए कि फ़ज़र मॉड्यूल अपेक्षित रूप से काम करता है। निष्पादन बैकएंड एक ब्लैकबॉक्स हैं इसलिए आपको यह सुनिश्चित करने के लिए निष्पादन ट्रेस उत्पन्न करने चाहिए कि यह सही पथों से गुज़रता है, सही काम करता है। इस चरण के दौरान मैं मुख्य रूप से [bochscpu](https://github.com/yrp604/bochscpu) बैकएंड का उपयोग करता हूं क्योंकि यह पूरी तरह से नियतात्मक है, तेज़ी से शुरू होता है, निष्पादन ट्रेस उत्पन्न करना संभव है, कोड-कवरेज मुफ्त में मिलता है, आदि। कुल मिलाकर, यह विकास और प्रोटोटाइप के लिए एक बेहतर वातावरण है।
एक बार जब आप मॉड्यूल से संतुष्ट हो जाते हैं, तो आप इसे [winhv](https://github.com/0vercl0k/wtf/blob/main/src/wtf/whv_backend.h) / [kvm](https://github.com/0vercl0k/wtf/blob/main/src/wtf/kvm_backend.h) बैकएंड के साथ काम करने के लिए देखना शुरू कर सकते हैं यदि आपको इसे उनके तहत चलाने की आवश्यकता है। *bochscpu* बैकएंड और दूसरों के बीच एक बड़ा अंतर यह है कि दूसरे कोड-कवरेज जानकारी प्रदान करने के लिए सॉफ्टवेयर ब्रेकपॉइंट का उपयोग करते हैं। परिणामस्वरूप, आपको [IDA](https://hex-rays.com/IDA-pro/) के तहत उन मॉड्यूल को लोड करना होगा जिनके लिए आप कवरेज चाहते हैं और [gen_coveragefile_ida.py](https://github.com/0vercl0k/wtf/blob/main/scripts/gen_coveragefile_ida.py) स्क्रिप्ट का उपयोग करके एक सरल JSON फ़ाइल उत्पन्न करनी होगी जो wtf द्वारा लोड की जाती है। आप इस JSON फ़ाइल को स्वयं किसी भी उपकरण का उपयोग करके उत्पन्न करने के लिए स्वतंत्र हैं: यह मूल रूप से बुनियादी-ब्लॉकों के वर्चुअल पतों की एक सूची है।
आप स्नैपशॉट बनाने से ठीक पहले 64-बिट संदर्भ पर स्विच करने के लिए `!wow64exts.sw` Windbg कमांड का उपयोग करके [WoW64](https://docs.microsoft.com/en-us/windows/win32/winprog64/wow64-implementation-details) अनुप्रयोगों को भी लक्षित कर सकते हैं (इस ट्रिक को साझा करने के लिए [@cube0x8](https://twitter.com/cube0x8) को धन्यवाद!):```
32.kd:x86> !wow64exts.sw
The context is partially valid. Only x86 user-mode context is available.
Switched to Host mode
32.kd> !snapshot
```
## मैं अपने लक्ष्य पर मल्टी-पैकेट कैसे भेजूं?
जटिल लक्ष्यों में आमतौर पर जटिल स्थितियाँ भी होती हैं और संभावना है कि जटिल समस्याओं को ट्रिगर करने के लिए आपको एक सत्र में एक से अधिक टेस्टकेस देने की आवश्यकता हो सकती है। [tlv_server.cc](https://github.com/0vercl0k/wtf/blob/main/src/tlv_server/tlv_server.cc) ऐसे सर्वर का एक उदाहरण है जहां केवल एक टेस्टकेस के साथ पार्सिंग फ़ंक्शन का अभ्यास करना बग्स को उजागर करने के लिए पर्याप्त नहीं होगा।
इस स्थिति को संभालने के लिए, [fuzzer_tlv_server.cc](https://github.com/0vercl0k/wtf/blob/main/src/wtf/fuzzer_tlv_server.cc) देखें जो दिखाता है कि इस समस्या को कैसे हल किया जाए।
## एक कस्टम म्यूटेटर / जनरेटर कैसे प्रदान करें?
**wtf** दो लोकप्रिय जेनेरिक म्यूटेटर के साथ आता है: [libfuzzer](https://github.com/0vercl0k/wtf/blob/main/src/wtf/mutator.h) और [honggfuzz](https://github.com/0vercl0k/wtf/blob/main/src/wtf/mutator.h)। आप अपना स्वयं का म्यूटेटर प्रदान करना चाह सकते हैं या स्वयं टेस्टकेस जनरेट करना चाह सकते हैं।
ऐसा करने के लिए, आप [Mutator_t](https://github.com/0vercl0k/wtf/blob/main/src/wtf/mutator.h) इंटरफ़ेस को सबक्लास कर सकते हैं, और उस फ़ंक्शन को रजिस्टर कर सकते हैं जो आपके फ़ज़िंग मॉड्यूल को परिभाषित करते समय आपके म्यूटेटर को इंस्टेंटिएट करता है:```c++
class CustomMutator_t : public Mutator_t {
public:
static std::unique_ptr<Mutator_t> Create(std::mt19937_64 &Rng,
const size_t TestcaseMaxSize) {
return std::make_unique<CustomMutator_t>(Rng, TestcaseMaxSize);
}
// ...
};
---
[Read more](https://github.com/0vercl0k/wtf)