`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

<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/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/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/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/HEAD/src/wtf/fuzzer_hevd.cc) बनाएं, वह कोड लिखें जो आपके लक्ष्य में [एक परीक्षण-केस डालता है](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_hevd.cc#L20) और [the](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_hevd.cc#L81) [various](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_hevd.cc#L104) [conditions](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_hevd.cc#L115) को [क्रैश का पता लगाने](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_hevd.cc#L115) या [परीक्षण-केस के अंत](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_hevd.cc#L69) के लिए परिभाषित करें।

1. आप [Mutator_t](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/mutator.h) इंटरफ़ेस को उपवर्गीकृत करके अपना स्वयं का म्यूटेटर/जनरेटर भी बना सकते हैं। [fuzzer_tlv_server.cc](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_tlv_server.cc) यह समझने के लिए एक अच्छा उदाहरण है कि आप अपना स्वयं का कार्यान्वयन कैसे कर सकते हैं।

इस बिंदु पर आपको पुनरावृत्ति शुरू करनी चाहिए और सत्यापित करना चाहिए कि फ़ज़र मॉड्यूल अपेक्षित रूप से काम करता है। निष्पादन बैकएंड एक ब्लैकबॉक्स हैं इसलिए आपको यह सुनिश्चित करने के लिए निष्पादन ट्रेस उत्पन्न करने चाहिए कि यह सही पथों से गुज़रता है, सही काम करता है। इस चरण के दौरान मैं मुख्य रूप से [bochscpu](https://github.com/yrp604/bochscpu) बैकएंड का उपयोग करता हूं क्योंकि यह पूरी तरह से नियतात्मक है, तेज़ी से शुरू होता है, निष्पादन ट्रेस उत्पन्न करना संभव है, कोड-कवरेज मुफ्त में मिलता है, आदि। कुल मिलाकर, यह विकास और प्रोटोटाइप के लिए एक बेहतर वातावरण है।

एक बार जब आप मॉड्यूल से संतुष्ट हो जाते हैं, तो आप इसे [winhv](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/whv_backend.h) / [kvm](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/kvm_backend.h) बैकएंड के साथ काम करने के लिए देखना शुरू कर सकते हैं यदि आपको इसे उनके तहत चलाने की आवश्यकता है। *bochscpu* बैकएंड और दूसरों के बीच एक बड़ा अंतर यह है कि दूसरे कोड-कवरेज जानकारी प्रदान करने के लिए सॉफ्टवेयर ब्रेकपॉइंट का उपयोग करते हैं। परिणामस्वरूप, आपको [IDA](https://hex-rays.com/IDA-pro/) के तहत उन मॉड्यूल को लोड करना होगा जिनके लिए आप कवरेज चाहते हैं और [gen_coveragefile_ida.py](https://github.com/0vercl0k/wtf/blob/HEAD/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

Check out the [CustomMutator_t](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_tlv_server.cc) class in the [fuzzer_tlv_server.cc](https://github.com/0vercl0k/wtf/blob/HEAD/src/wtf/fuzzer_tlv_server.cc) module for a complete example.

## निष्पादन बैकएंड्स

इस अनुभाग में मैं निष्पादन बैकएंड्स के बीच विभिन्न अंतरों का संक्षेप में उल्लेख करता हूँ।

### bochscpu
- ✅ पूर्ण सिस्टम कोड-कवरेज (`--edges` के माध्यम से एज कवरेज उपलब्ध),
- ✅ डिमांड-पेजिंग,
- ✅ टाइमआउट निर्देशों की संख्या है जो बहुत सटीक है,
- ✅ पूर्ण निष्पादन ट्रेस समर्थित हैं,
- ✅ पूरी तरह से नियतात्मक,
- ❌ गति छोटे निष्पादनों के लिए अच्छी लगती है लेकिन लंबे निष्पादनों के लिए नहीं (जब मैं IDA को फजिंग कर रहा था तो KVM से ~100x धीमी)।

### whv
- ✔ सॉफ्टवेयर ब्रेकपॉइंट के माध्यम से कोड-कवरेज,
- ❌ डिमांड-पेजिंग इसलिए स्टार्ट-अप धीमा है (क्योंकि इसे पूरे क्रैश-डंप को मेमोरी में लोड करने की आवश्यकता है),
- ✔ टाइमआउट टाइमर के साथ लागू किया गया है,
- ✅ पूर्ण निष्पादन ट्रेस समर्थित हैं लेकिन धीमे हैं (VMX से बाहर निकलना महंगा है),
- ✔ यदि गैर-नियतत्ववाद के स्रोत को मैन्युअल रूप से संभाला जाए तो नियतात्मक (उदाहरण के लिए, `nt!ExGenRamdom` को पैच करना जो `rdrand` का उपयोग करता है),
- ✔ लंबे निष्पादनों के लिए गति ठीक लगती है (हालांकि whv में बहुत सारी बाधाएँ हैं; जब मैं IDA को फजिंग कर रहा था तो kvm से ~10x धीमी)।

### KVM
- ✔ सॉफ्टवेयर ब्रेकपॉइंट के माध्यम से कोड-कवरेज,
- ✅ UFDD के माध्यम से डिमांड-पेजिंग समर्थित है,
- ✔ टाइमआउट टाइमर के साथ लागू किया गया है। ✅ यदि हार्डवेयर PMU वर्चुअलाइजेशन का समर्थन करता है, तो इसका उपयोग X सेवानिवृत्त निर्देशों के बाद [PMI](https://forum.osdev.org/viewtopic.php?f=1&t=27040) उत्पन्न करने के लिए किया जाता है (`MSR_IA32_FIXED_CTR0`),
- ✅ पूर्ण निष्पादन ट्रेस समर्थित हैं लेकिन धीमे हैं (VMX से बाहर निकलना महंगा है),
- ✔ यदि गैर-नियतत्ववाद के स्रोत को मैन्युअल रूप से संभाला जाए तो नियतात्मक (उदाहरण के लिए, `nt!ExGenRamdom` को पैच करना जो `rdrand` का उपयोग करता है),
- ✅ लंबे निष्पादनों के लिए सबसे तेज़ (~500 मिलियन - 1.5 बिलियन निर्देश; जब मैं IDA को फजिंग कर रहा था तो *bochscpu* से ~100x तेज़, *whv* से ~10x तेज़)।

## बिल्ड

[CI](https://github.com/0verclk0/wtf/actions/workflows/wtf.yml) **wtf** को Ubuntu पर [clang++](https://clang.llvm.org/) / [g++](https://gcc.gnu.org/gcc-11/) दोनों का उपयोग करके, Windows पर Microsoft के [Visual Studio](https://visualstudio.microsoft.com/vs/community/) का उपयोग करके और OSX पर [clang++](https://clang.llvm.org/) का उपयोग करके बिल्ड करता है।

इसे स्वयं बनाने के लिए आपको एक *Visual Studio Developper Command Prompt* प्रारंभ करना होगा और या तो [build-release.bat](https://github.com/0vercl0k/wtf/blob/HEAD/src/build/build-release.bat) चलाना होगा जो [Ninja](https://ninja-build.org/) जनरेटर का उपयोग करता है या Visual Studio समाधान फ़ाइल उत्पन्न करने के लिए [build-release-msvc.bat](https://github.com/0vercl0k/wtf/blob/HEAD/src/build/build-release-msvc.bat) चलाना होगा:```
(base) wtf\src\build>build-release.bat
[...]
[2/2] Linking CXX executable wtf.exe

(base) wtf\src\build_msvc>..\build\build-release-msvc.bat
[...]
  Finished generating code
  wtf.vcxproj -> wtf\src\build_msvc\RelWithDebInfo\wtf.exe
  Building Custom Rule wtf/src/CMakeLists.txt