mkPIVM

पढ़ें शोध पत्र (1.0.0 के लिए लिखा गया)।

mkPIVM एक बहुरूपी स्थिति-स्वतंत्र शेलकोड वर्चुअलाइज़र है जो Windows x86 और x64 (जल्द ही Linux) के लिए है।

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

क्यों: नेटिव शेलकोड हस्ताक्षर-तुच्छ है। इसे प्रति-उदाहरण VM में प्रति-उदाहरण सिफर के साथ लपेटने से आराम पर कुछ भी उपयोगी नहीं बचता, और निर्देशों को बाइटकोड में उठाना डिस्क बाइट्स और किसी भी डिसअसेंबलर के बीच एक और दीवार डालता है जो x86 को जानता है। जहां तक मैं साहित्य सर्वेक्षण से बता सकता हूं, कोई सार्वजनिक उपकरण बिल्कुल इस पाइपलाइन को शिप नहीं करता: रॉ PIC इन, रॉ बहुरूपी VM PIC आउट। तो, मैंने इसका उल्लेख शोध पत्र में किया जिसकी मांग की गई थी। सच कहूं तो, अगर मैं इस बारे में सही हूं कि किसी ने पहले (सार्वजनिक रूप से) ऐसा नहीं किया है, और मुझे काफी भरोसा है, तो मुझे आश्चर्य है। फिर भी, आनंद लें।

संबंधित कार्य और योजनाएँ

• Linux समर्थन जल्द ही जोड़ा जाएगा।

त्वरित आरंभ```

mkpivm.exe shellcode.bin --arch x64 -o out.bin

आपका PIVM गर्म और तैयार है। यह सबसे सरल रास्ता है। कई अन्य मोड अलग-अलग होते हैं कि मूल निर्देश कितने आक्रामक रूप से वर्चुअलाइज़ होते हैं, आउटपुट एक स्टैंडअलोन ब्लॉब है या पैच किया गया PE, और लिफ्ट बिल्कुल चलती है या नहीं।

# Showcase

मेरे पास सबूत हैं। आप नीचे mkPIVM के काम करने का एक वीडियो देख सकते हैं, जो एक Meterpreter स्टेजर (वैनिला btw) को पूरी तरह से वर्चुअलाइज़ कर रहा है, explorer.exe में इंजेक्ट कर रहा है, और हम कॉलबैक कैप्चर कर रहे हैं। बेशक यह सिर्फ एक उदाहरण है, और mkPIVM को और भी अधिक पर लागू किया जा सकता है, बशर्ते शेलकोड में निर्देश समर्थित हों। यदि वे समर्थित नहीं हैं, तो एक Issue बनाएं, मुझे शेलकोड भेजें, मैं संभाल लूंगा।

इसे [here](https://github.com/D7EAD/mkPIVM/raw/refs/heads/main/media/mkpivm-showcase.mp4) देखें। ./media में होस्ट किया गया है, दुर्भाग्य से एम्बेड नहीं कर सकते।

यहाँ उसी वर्चुअलाइज़्ड सैंपल का VirusTotal रिपोर्ट है (06/04/2026 तक)।

<img src="https://assets.kitploit.com/production/public/readmes/7466/3f4a6dbe2777c02fb32f71749a5b1fa2aa324cb0dac2f77d5681bbe3a4e17a81.png">

...और पैक किया गया संस्करण, वर्चुअलाइज़ भी नहीं किया गया, विशेष रूप से उच्च एंट्रॉपी।

<img src="https://assets.kitploit.com/production/public/readmes/7466/47f68372e31a2c24fa49eb71648adbdf8944977db90d645df337125c1bdfa8e3.png">

तुलना के लिए एक सामान्य Cobalt Strike बीकन के परिणाम।

<img src="https://assets.kitploit.com/production/public/readmes/7466/76e2107589cd2b1b65c846a671aed173aa5e6d89630f5e9d283d99c546a2d566.png">

इस उपकरण के आउटपुट के एंट्रॉपी टेलीमेट्री पर सावधानीपूर्वक ध्यान दिया गया, जिसके परिणामस्वरूप शेलकोड की एंट्रॉपी सामान्य Windows WinAPI DLLs (पैकिंग मोड के बाहर) जैसे ntdll.dll या kernel32.dll से कम होती है। एंट्रॉपी तुलना लगभग है...

| फ़ाइल | बाइट्स | एंट्रॉपी |
|------|-------|---------|
| `p_m64.bin` | 3,969 | **7.1181** |
| `msvcrt.dll` | 699,888 | 6.5319 |
| `wininet.dll` | 2,724,528 | 6.4934 |
| `shell32.dll` | 7,839,992 | 6.3639 |
| `kernel32.dll` | 836,232 | 6.3597 |
| `crypt32.dll` | 1,538,632 | 6.3010 |
| `rpcrt4.dll` | 1,162,672 | 6.2405 |
| `ntdll.dll` | 2,522,104 | 6.1934 |
| `v.bin` | 29,229 | **6.0442** |

## एक नज़र में मोड

| मोड | फ़्लैग | क्या बदलता है |
|------|-------|--------------|
| Default | none | पूरे इनपुट को उठाएं। सब कुछ वर्चुअलाइज़्ड। |
| Packer | `--pack` | लिफ्ट न करें। इनपुट को एन्क्रिप्टेड डेटा के रूप में लपेटें, रनटाइम पर डिक्रिप्ट करें, और उसमें कूदें। |
| Hybrid | `--ranges A:B,...` | केवल चुने गए बाइट रेंज को उठाएं। बाकी नेटिव रहता है। |
| Stacked | `--pack --ranges A:B` | हाइब्रिड ब्लॉब बनाएं, फिर इसे पैक-रैप करें। |
| Detour | `--embed-into PE --at RVA` | पहले से निर्मित ब्लॉब लें, PE में एम्बेड करें, चयनित RVA पर jmp पैच करें। |
| Scan | `--scan` | इनपुट के CFG से पात्र `--ranges` उम्मीदवारों को प्रिंट करें, फिर बाहर निकलें। |
| RX | `--rx` | PAGE_EXECUTE_READ ब्लॉब। डेटा आइलैंड आराम पर एन्क्रिप्टेड रहता है; इन-ब्लॉब PEB वॉकर VirtualProtect को हल करता है, state_init पर इन-प्लेस डिक्रिप्ट करता है। |
| RX w/ Loader | `--rx --rx-loader-vp` | `--rx` की तरह, लेकिन आपका लोडर VirtualProtect को ब्लॉब के पहले आर्ग के रूप में पास करता है। कोई PEB वॉकर नहीं। |

हर मोड `--seed`, `--arch`, `--input-format`, और `--format` का सम्मान करता है। बिल्ड पाइपलाइन और रनटाइम फ्लो के लिए नीचे प्रति-मोड अनुभाग देखें।

## डिफ़ॉल्ट वर्चुअलाइज़ेशन

लिफ्टर पूरे CFG पर चलता है और हर निर्देश को एक कस्टम IR में बदल देता है। IR दो ऑब्फस्केशन पास से गुज़रता है, फिर कोडेक्स से होकर जाता है जो प्रत्येक insn को प्रति-सीड बाइटकोड आकार में एनकोड करते हैं। ब्लॉक टेबल, हैंडलर टेबल, और डेटा आइलैंड को बाइटकोड के समान प्रति-बाइट स्ट्रीम सिफर से एन्क्रिप्ट किया जाता है। रनटाइम पर प्रोलॉग उन तीन क्षेत्रों को इन-प्लेस डिक्रिप्ट करता है और डिस्पैचर लूप एक-एक करके बाइटकोड बाइट्स लाता है, डिक्रिप्ट करता है और एक हैंडलर को डिस्पैच करता है जो काम करता है।

### बिल्ड पाइपलाइन

बिल्ड द्वारा कच्चे शेलकोड को निकाले गए वर्चुअलाइज़्ड ब्लॉब में बदलने के लिए किए जाने वाले कदम, शुरू से अंत तक। _नीचे सभी ग्राफ 1.0.0 रिलीज़ पर लागू होते हैं, तब से ये बदल गए हैं, लेकिन विचार वही है।_```mermaid
flowchart TB
    A[shellcode.bin] --> CFG[CFGBuilder: identify blocks via Zydis disasm + recursive descent]
    SEED[seed u64] --> VMC[VMConfig: pick cipher kind, reg perm, opcode map, dispatcher topology]
    CFG --> LIFT[LifterRegistry: lower each block to IR]
    LIFT --> RBT[resolve_branch_targets: link BR_CC/BR/CALL_VM/LOOP_DEC to target_block_id; synthesize JMP_NATIVE block for any out-of-range jcc]
    RBT --> OBF1[obfuscate_ir_dead_inject: 20% per insn-gap, IMM Tmp2/Tmp3 random]
    OBF1 --> OBF2[obfuscate_ir_opaque_predicates: 25% per block, split block with IMM Tmp3=0 + TEST + BR_CC NZ random_block, never taken]
    OBF2 --> ENC[BytecodeBuilder: each codec emits its variant for this seed]
    ENC --> CDATA[compact data island: bytes not covered by any CFG block]
    CDATA --> PROMO[promote LEA-fixup target VAs back into data island if CFG put them in code]
    ENC --> BTAB[build block table: va_off to bytecode_off pairs]
    PROMO --> ECIPH[encrypt data island with cipher_init]
    BTAB --> ECIPH2[encrypt block table with cipher_init]
    ENC --> ECIPH3[encrypt bytecode per-block with cipher_init reset at each block start]
    VMC --> STUB[VMCodeGen::emit_full: prologue, state init, dispatcher tail, handlers, sbox_inv, exit handler]
    STUB --> HTAB[handler table: 256 entries, each a 32-bit offset from handler_base; encrypted at rest]
    ECIPH --> ASM[finalize: stub + trampolines + sbox_inv + bytecode + data island + block table]
    ECIPH2 --> ASM
    ECIPH3 --> ASM
    HTAB --> ASM
    ASM --> OUT[out.bin]

रनटाइम प्रवाह