Resumen ejecutivo
A principios de mayo de 2025, los investigadores de Unit 42 observaron que AdaptixC2 se utilizó para infectar varios sistemas.
AdaptixC2 es un marco de emulación adversaria y postexplotación de código abierto recientemente identificado, creado para los evaluadores de infiltraciones, que los actores de amenazas están utilizando en sus campañas. A diferencia de muchos marcos C2 conocidos, AdaptixC2 ha pasado prácticamente desapercibido. Hay poca documentación pública disponible que demuestre su uso en ataques reales. Nuestra investigación analiza lo que AdaptixC2 puede hacer, ayudando a los equipos de seguridad a defenderse contra él.
AdaptixC2 es un marco versátil para la explotación posterior. Los actores de amenazas lo utilizan para ejecutar comandos, transferir archivos y realizar la exfiltración de datos en sistemas comprometidos. Al ser de código abierto, los actores de amenazas pueden personalizarlo y adaptarlo fácilmente a sus objetivos específicos. Esto lo convierte en una herramienta muy flexible y peligrosa.
La aparición de AdaptixC2 como herramienta utilizada por los actores de amenazas pone de relieve una tendencia creciente entre los atacantes a utilizar marcos personalizables para evadir la detección.
Los clientes de Palo Alto Networks están mejor protegidos frente a las amenazas descritas en este artículo gracias a los siguientes productos:
- Seguridad DNS avanzada
- Prevención de amenazas avanzada
- URL Filtering avanzado
- WildFire avanzado
- Cortex XDR y XSIAM
Si cree que puede haber resultado vulnerado o tiene un problema urgente, póngase en contacto con el equipo de respuesta ante incidentes de Unit 42.
Temas relacionados con Unit 42 | Pentesting Tools, C2 |
Análisis técnico del marco adversarial AdaptixC2
AdaptixC2 es un marco C2 de código abierto que recientemente hemos visto utilizado en varios ataques reales.
Identificamos dos infecciones por AdaptixC2. En un caso se utilizaron técnicas de ingeniería social. Consideramos muy probable que en el otro se utilizaran herramientas de generación de código basadas en IA.
Funcionalidad de AdaptixC2
AdaptixC2 es una herramienta de equipo rojo que se puede utilizar para realizar acciones adversarias y que se puede ampliar para personalizarla. Si esto fuera utilizado por un actor de amenazas, podría controlar de forma integral las máquinas afectadas para ejecutar una amplia gama de acciones. Estas incluyen:
- Manipulación del sistema de archivos
- Listado de directorios
- Creación, modificación y eliminación de archivos y carpetas
- Enumeración de procesos en ejecución
- Terminación de aplicaciones específicas
- Ejecución de nuevos programas
Los actores de amenazas utilizan estas capacidades para establecer y mantener un punto de apoyo en un entorno, explorar más a fondo el sistema comprometido y moverse lateralmente dentro de la red.
Para facilitar la comunicación encubierta y eludir las restricciones de red, el marco admite sofisticadas capacidades de tunelización, incluida la funcionalidad de proxy SOCKS4/5 y el reenvío de puertos. Esto permite a los atacantes mantener los canales de comunicación incluso si la red está muy protegida.
AdaptixC2 está diseñado para ser modular, y utiliza “extensores” que actúan como complementos tanto para los oyentes como para los agentes. Esto permite a los hackers crear cargas útiles personalizadas y formas de evitar la detección específicas para el sistema que están atacando. AdaptixC2 también es compatible con los archivos Beacon Object Files (BOF), que permiten a los atacantes ejecutar pequeños programas personalizados escritos en C directamente dentro del proceso del agente para evadir la detección.
Los agentes de baliza de AdaptixC2 están equipados con comandos específicos para transferir datos de forma rápida y secreta. Estos agentes son compatibles con las arquitecturas x86 y x64, y se pueden generar en varios formatos, entre los que se incluyen:
- Ejecutables independientes (EXE)
- Bibliotecas de vínculos dinámicos (DLL)
- Ejecutables de servicio
- Shellcode sin procesar
Los atacantes pueden utilizar el marco AdaptixC2 para robar datos de la red comprometida. Esta funcionalidad de exfiltración de datos permite configurar el tamaño de los fragmentos para la descarga y carga de archivos, ya que la detección basada en la red tiende a considerar los segmentos más pequeños como menos sospechosos.
La interfaz AdaptixC2 muestra los agentes y sesiones vinculados en una vista gráfica. En la Figura 1 se muestra la perspectiva de un atacante sobre cómo avanzan los ataques en varias etapas y qué rutas hay disponibles para moverse por una red objetivo.

AdaptixC2 también cuenta con funciones que ayudan al atacante a mantener la seguridad operativa (OpSec). Entre ellos se incluyen parámetros que los ayudan a mezclarse con el tráfico normal de la red:
- KillDate: establece una fecha para que la baliza deje de funcionar.
- WorkingTime: configura la baliza para que solo esté activa durante determinadas horas.
Además, los actores de amenazas pueden modificar y mejorar el agente con técnicas personalizadas de ofuscación, antianálisis y evasión, lo que lo convierte en una amenaza en constante evolución.
Configuración
La configuración de AdaptixC2 está cifrada y admite tres tipos principales de balizas a través de estructuras de perfil especializadas:
- BEACON_HTTP para la comunicación basada en web
- BEACON_SMB para la comunicación mediante canalización con nombre
- BEACON_TCP para conexiones TCP directas
El perfil HTTP es la variante de baliza más común y contiene parámetros típicos de comunicación web, tales como:
- Servidores
- Puertos
- Configuración SSL
- Métodos HTTP
- URI
- Encabezados
- Cadenas de agente de usuario
El perfil SMB utiliza canalizaciones con nombre de Windows cuando HTTP puede estar bloqueado o supervisado. El perfil TCP se utiliza para crear conexiones directas de socket con la opción de anteponer datos para el ocultamiento básico del protocolo.
AdaptixC2 incluye una configuración predeterminada integrada que muestra los parámetros de implementación típicos. El perfil HTTP predeterminado apunta a 172.16.196.1:4443 y utiliza comunicación HTTPS, con un método POST al punto final /uri.php y el parámetro X-Beacon-Id para la identificación de balizas.
En la Figura 2 se muestra cómo configurar la baliza.

Después de hacer clic en “Crear”, el generador de balizas cifra la configuración con RC4 y, a continuación, la integra en la baliza compilada. La configuración cifrada se almacena de la siguiente manera:
- 4 bytes: Tamaño de la configuración (entero de 32 bits)
- N bytes: Datos de configuración cifrados con RC4
- 16 bytes: Clave de cifrado RC4
El siguiente código es la lógica de extracción de claves, tomada de AgentConfig.cpp:
1 2 3 4 5 6 7 |
ULONG profileSize = packer->Unpack32(); this->encrypt_key = (PBYTE) MemAllocLocal(16); memcpy(this->encrypt_key, packer->data() + 4 + profileSize, 16); DecryptRC4(packer->data()+4, profileSize, this->encrypt_key, 16); |
Extracción de la configuración de muestras malintencionadas
Dado que el cifrado es sencillo y predecible, los defensores pueden desarrollar un extractor que extraiga automáticamente las configuraciones de las muestras. Esta herramienta de extracción debería funcionar de la misma manera que la baliza carga sus propias configuraciones.
El extractor localiza la configuración en la sección .rdata del archivo PE. A continuación, extrae el tamaño (los primeros cuatro bytes), el bloque de datos cifrados y la clave RC4 (los últimos 16 bytes). Después de utilizar la clave RC4 integrada para descifrar los datos, analiza la configuración del texto sin formato descomprimiendo los siguientes campos:
- Tipo de agente
- Indicador SSL
- Número de servidores
- Servidores/puertos
- Parámetros HTTP
- Ajustes de sincronización
Utilizando este método, hemos creado una herramienta capaz de procesar muestras AdaptixC2 y obtener sus configuraciones integradas. El código completo del extractor es compatible con la variante BEACON_HTTP. Esta herramienta se proporciona en la sección Ejemplo de extractor de configuración. Los investigadores pueden utilizar este extractor para analizar muestras de AdaptixC2 o adaptar el código para otras variantes.
A continuación se muestra la configuración predeterminada integrada de la baliza.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
{ "agent_type": 3192652105, "use_ssl": true, "servers_count": 1, "servers": ["172.16.196.1"], "ports": [4443], "http_method": "POST", "uri": "/uri.php", "parameter": "X-Beacon-Id", "user_agent": "Mozilla/5.0 (Windows NT 6.2; rv:20.0) Gecko/20121202 Firefox/20.0", "http_headers": "\r\n", "ans_pre_size": 26, "ans_size": 47, "kill_date": 0, "working_time": 0, "sleep_delay": 2, "jitter_delay": 0, "listener_type": 0, "download_chunk_size": 102400 } |
Escenarios de AdaptixC2
Situación 1: el falso servicio de asistencia técnica provoca la infección por AdaptixC2
En mayo de 2025, investigamos varios incidentes en los que los actores de amenazas instalaron balizas AdaptixC2. En algunos casos, observamos que los actores de amenazas utilizaban el mismo vector de ataque, como se muestra en la Figura 3.

Compromiso inicial
Los actores de amenazas se aprovecharon de la confianza en Microsoft Teams para engañar a las personas y que les dieran acceso a los sistemas de la empresa. En un caso, los atacantes utilizaron ataques de phishing para suplantar al personal de soporte informático (con asuntos como “Asistencia técnica (externa) | Microsoft Teams”). Esto convenció a los empleados para iniciar sesiones legítimas de asistencia remota mediante herramientas como Quick Assist Remote Monitoring and Management (RMM).
Los actores de amenazas suelen abusarde productos legítimos con fines malintencionados. Esto no implica necesariamente que el producto legítimo que se está utilizando indebidamente tenga algún defecto o sea malintencionado.
Informe global de respuesta ante incidentes de Unit 42 de 2025: La edición sobre ingeniería social señaló que las técnicas de ingeniería social como esta son el vector de acceso inicial más frecuente para los ataques que observamos. Este acceso inicial proporciona a los atacantes un punto de apoyo dentro del sistema objetivo, sin tener que eludir las defensas perimetrales, como los firewalls y los sistemas de detección de intrusiones.
Implementación y persistencia de AdaptixC2 mediante la ejecución de shellcode
Los atacantes implementaron la baliza AdaptixC2 con un cargador PowerShell de varias etapas que descarga una carga útil codificada y cifrada desde un enlace a un servicio legítimo.
Una vez descargado, el script de PowerShell descifra la carga útil mediante una clave XOR simple. En lugar de escribir la carga útil descifrada en el disco, lo que facilitaría su detección, el script aprovecha las capacidades de .NET para asignar memoria dentro del propio proceso de PowerShell. A continuación, el script copia la carga útil descifrada, que en realidad es shellcode, en esta región de memoria asignada. Este enfoque sin archivos reduce significativamente la huella del atacante en el sistema.

El script utiliza una técnica denominada “invocación dinámica” para ejecutar el shellcode directamente desde la memoria. Para ello, utiliza el método GetDelegateForFunctionPointer, que crea dinámicamente un delegado (un puntero de función seguro para el tipo) que apunta al comienzo del shellcode en la memoria. A continuación, el script llama a este delegado como si fuera una función normal, y ejecuta el shellcode de forma efectiva sin escribir un archivo ejecutable en el disco. Para garantizar que el proceso malicioso se inicie automáticamente después de reiniciar el sistema, el script crea un acceso directo en la carpeta de inicio. En la Figura 4 se muestra el script de PowerShell.

La variante de la baliza cargada en este ataque tenía la siguiente configuración:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
{ "agent_type": 3192652105, "use_ssl": true, "servers_count": 1, "servers": [ "tech-system[.]online" ], "ports": [ 443 ], "http_method": "POST", "uri": "/endpoint/api", "parameter": "X-App-Id", "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.6167.160 Safari/537.36", "http_headers": "\r\n", "ans_pre_size": 26, "ans_size": 47, "kill_date": 0, "working_time": 0, "sleep_delay": 4, "jitter_delay": 0, "listener_type": 0, "download_chunk_size": 102400 } |
Actividad posterior a la explotación y contención
Después de la implementación exitosa de AdaptixC2, los atacantes empezaron a hacer reconocimiento, con herramientas de línea de comandos para juntar información sobre los sistemas y la red que habían sido comprometidos. Esto incluía comandos de detección como nltest.exe, whoami.exe e ipconfig.exe.
A continuación, la baliza estableció comunicación con un servidor remoto, lo que permitió a los actores de amenazas obtener C2 en la máquina infectada.
Situación 2: infección relacionada con un script generado por IA
En otro caso, los actores de amenazas implementaron un script de PowerShell diseñado para implementar balizas AdaptixC2. Evaluamos con un alto grado de confianza que este script fue generado por IA. Esta implementación se realizó tanto mediante la inyección de shellcode en memoria como a través de un mecanismo de persistencia basado en el secuestro de DLL. El script, que se muestra en la Figura 5, se centra en permanecer oculto en el sistema afectado para proporcionar a los hackers un punto de apoyo sólido.

Análisis detallado del PowerShell generado por IA
- Descarga y decodificación del shellcode: el script descarga una carga útil de shellcode codificada en Base64 desde un servidor remoto con el método Invoke-RestMethod. A continuación, se decodifica el contenido descargado.
- Asignación de memoria, copia de shellcode y cambio de la protección de memoria: el script asigna un bloque de memoria no gestionada. A continuación, el shellcode AdaptixC2 se copia en la memoria asignada y cambia los atributos de protección de memoria de la región de memoria asignada mediante VirtualProtect a 0x40 (PAGE_EXECUTE_READWRITE). Esto permite la ejecución del shellcode.
- Ejecución de shellcode mediante invocación dinámica: como en el caso anterior, el atacante utilizó GetDelegateForFunctionPointer para crear una instancia delegada que apunta al comienzo del shellcode en la memoria. A continuación, el atacante utilizó el método Invoke() para ejecutar el shellcode, lanzando la baliza en memoria.
- Persistencia del secuestro de DLL: El script apunta al directorio APPDATA\Microsoft\Windows\Templates para el secuestro de DLL, a través del archivo msimg32.dll. Este DLL también es una versión de baliza.
- Persistencia mediante la clave de ejecución del registro: El script crea una entrada de registro en la clave de ejecución denominada "Updater", con un comando PowerShell que ejecuta el script loader.ps1. Esto garantiza que el script loader.ps1 se ejecute cada vez que el usuario inicie sesión, para ejecutar la baliza.
Generación de scripts con IA
La estructura y composición de este script de PowerShell sugiere claramente que el atacante utilizó generación asistida por IA. Los siguientes elementos estilísticos se observan comúnmente en el código generado por herramientas de IA:
- Comentarios detallados y numerados:
- "# === [1] Descargar y decodificar el shellcode ==="
- Iconos de marca de verificación en el mensaje de salida:
- Escribir salida "[✔] Persistencia establecida mediante la clave Run y secuestro de DLL. DLL colocada en $templatesPath"
Evaluamos con un alto grado de confianza que el código se generó con la ayuda de la IA. Esto se basa en los factores anteriores, así como en las pruebas recopiladas del servidor del atacante y los resultados extraídos de dos detectores de IA independientes.
Las herramientas de IA sin las medidas de seguridad adecuadas pueden permitir a los atacantes desarrollar rápidamente código malintencionado, lo que facilita la ejecución de operaciones en redes infectadas.
Similitudes entre los casos
En ambos incidentes se observó un patrón constante:
- Cargadores basados en PowerShell
- Los actores de amenazas utilizaron estos cargadores para implementar la baliza AdaptixC2, dando prioridad al acceso sigiloso y persistente.
- Descargar una carga útil desde un servidor remoto y ejecutarla en la memoria.
- El uso de un recurso legítimo ayudó a los atacantes a pasar desapercibidos, al minimizar los rastros detectables en el disco.
- Basándose en las capacidades de .NET para la asignación de memoria y la invocación dinámica.
- Los actores de amenazas aprovecharon las funcionalidades integradas del sistema, como el método GetDelegateForFunctionPointer, para ejecutar shellcode, con el fin de ganar en eficiencia y sigilo.
- Prevención de la eliminación de balizas mediante mecanismos de persistencia
- Mientras que el primer script dependía únicamente de un acceso directo en la carpeta de inicio para su persistencia, el segundo añadía el secuestro de DLL.
- Esto proporciona a los atacantes más formas de permanecer en el sistema comprometido.
- Uso de convenciones de nomenclatura similares para script y claves de ejecución
- En un caso, los atacantes denominaron el script malicioso update.ps1. En otro, la clave de ejecución para la persistencia se denominó Updater.
- Esta denominación ayuda a que los scripts y las claves se mezclen con los procesos legítimos del sistema.
Aumento de la prevalencia del marco AdaptixC2
Nuestra telemetría e inteligencia de amenazas muestran que AdaptixC2 se está volviendo más común. Seguimos identificando nuevos servidores AdaptixC2, lo que sugiere que más actores de amenazas están adoptando este marco como parte de su kit de herramientas de ataque.
Esta tendencia va más allá de las situaciones típicas posteriores a la explotación. Por ejemplo, los atacantes implementaron el ransomware Fog junto con AdaptixC2 en un reciente ataque a una institución financiera en Asia. Esto demuestra que AdaptixC2 es versátil y puede utilizarse con otras herramientas malintencionadas, como el ransomware, para alcanzar objetivos más amplios.
Conclusión
AdaptixC2 es una amenaza adaptable, como lo demuestra su creciente popularidad entre los actores de amenazas y la complejidad de sus técnicas de implementación. La modularidad del marco, combinada con el potencial de la generación de código asistida por IA, podría permitir a los actores de amenazas evolucionar rápidamente sus tácticas. Los equipos de seguridad deben permanecer al tanto de las capacidades de AdaptixC2 y adaptar de forma proactiva sus defensas para contrarrestar esta amenaza.
Los clientes de Palo Alto Networks están mejor protegidos frente a las amenazas mencionadas gracias a los siguientes productos y servicios:
- URL Filtering avanzado y Seguridad DNS avanzada identifican como malintencionados los dominios y URL conocidos asociados con esta actividad.
- La prevención de amenazas avanzada cuenta con una detección integrada basada en aprendizaje automático que puede detectar exploits en tiempo real.
- Los modelos de aprendizaje automático y las técnicas de análisis de Advanced WildFire se han revisado y actualizado a la luz de los indicadores compartidos en esta investigación.
- Cortex XDR y XSIAM ayudan a prevenir el malware mediante el uso del motor de prevención de malware. Este enfoque combina varias capas de protección diseñadas para evitar que el malware conocido y desconocido cause daños a sus endpoints. Las técnicas de mitigación que emplea el motor de prevención de malware varían según el tipo de endpoint.
Si cree que puede haber resultado vulnerado o tiene un problema urgente, póngase en contacto con el equipo de respuesta ante incidentes de Unit 42 o llame al:
- Norteamérica: llamada gratuita: +1 (866) 486-4842 (866.4.UNIT42)
- Reino Unido: +44.20.3743.3660
- Europa y Oriente Medio: +31.20.299.3130
- Asia: +65.6983.8730
- Japón: +81.50.1790.0200
- Australia: +61.2.4062.7950
- India: 00080005045107
Palo Alto Networks ha compartido estos resultados con nuestros compañeros de Cyber Threat Alliance (CTA). Los miembros de CTA utilizan esta inteligencia para implementar rápidamente medidas de protección para sus clientes y desarticular sistemáticamente a los ciberdelincuentes. Obtenga más información sobre Cyber Threat Alliance.
Indicadores de vulneración
Valor | Tipo | Descripción |
bdb1b9e37f6467b5f98d151a43f280f319bacf18198b22f55722292a832933ab | SHA256 | Script de PowerShell que instala una baliza AdaptixC2 |
83AC38FB389A56A6BD5EB39ABF2AD81FAB84A7382DA296A855F62F3CDD9D629D | SHA256 | Script de PowerShell que instala una baliza AdaptixC2 |
19c174f74b9de744502cdf47512ff10bba58248aa79a872ad64c23398e19580b | SHA256 | Script de PowerShell que instala una baliza AdaptixC2 |
750b29ca6d52a55d0ba8f13e297244ee8d1b96066a9944f4aac88598ae000f41 | SHA256 | Script de PowerShell que instala una baliza AdaptixC2 |
b81aa37867f0ec772951ac30a5616db4d23ea49f7fd1a07bb1f1f45e304fc625 | SHA256 | Baliza AdaptixC2 como DLL |
df0d4ba2e0799f337daac2b0ad7a64d80b7bcd68b7b57d2a26e47b2f520cc260 | SHA256 | Baliza AdaptixC2 como EXE |
AD96A3DAB7F201DD7C9938DCF70D6921849F92C1A20A84A28B28D11F40F0FB06 | SHA256 | Shellcode que instala la baliza AdaptixC2 |
tech-system[.]online | Dominio | Dominio AdaptixC2 |
protoflint[.]com | Dominio | Dominio AdaptixC2 |
novelumbsasa[.]art | Dominio | Dominio AdaptixC2 |
picasosoftai[.]shop | Dominio | Dominio AdaptixC2 |
dtt.alux[.]cc | Dominio | Dominio AdaptixC2 |
moldostonesupplies[.]pro | Dominio | Dominio AdaptixC2 |
x6iye[.]site | Dominio | Dominio AdaptixC2 |
buenohuy[.]live | Dominio | Dominio AdaptixC2 |
firetrue[.]live | Dominio | Dominio AdaptixC2 |
lokipoki[.]live | Dominio | Dominio AdaptixC2 |
veryspec[.]live | Dominio | Dominio AdaptixC2 |
mautau[.]live | Dominio | Dominio AdaptixC2 |
muatay[.]live | Dominio | Dominio AdaptixC2 |
nicepliced[.]live | Dominio | Dominio AdaptixC2 |
nissi[.]bg | Dominio | Dominio AdaptixC2 |
express1solutions[.]com | Dominio | Dominio AdaptixC2 |
iorestore[.]com | Dominio | Dominio AdaptixC2 |
doamin[.]cc | Dominio | Dominio AdaptixC2 |
regonalone[.]com | Dominio | Dominio AdaptixC2 |
Reglas de Yara
Los defensores pueden utilizar estas reglas de Yara para comprobar la presencia de balizas AdaptixC2 en las máquinas.
Baliza AdaptixC2 HTTP/SMB/TCP
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
rule u42_hacktool_beacon_adaptixC2 { meta: description = "Detects AdaptixC2 beacon via basic functions" reference = "https://github.com/Adaptix-Framework/AdaptixC2" strings: $FileTimeToUnixTimestamp = {D1 65 F8 83 7D F4 1F 7E 17 8B 55 E4} $Proxyfire_RecvProxy = {B9 FC FF 0F 00 E8 6A 04 00 00} $timeCalc1 = {8D 82 A0 05 00 00 89 44 24 3C EB 07} $timeCalc2 = {FF D2 0F B7 44 24 28 66 3B} $b64_encoded_size = {83 C0 01 39 45 18 7E 22 8B 45 E4 C1 E0 08 89 C1} $manage = {C6 44 24 5F 00 48 8B 45 10 48 8B 00} condition: any of them } |
Baliza AdaptixC2 Go
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
rule u42_hacktool_beacon_adaptixC2 { meta: description = "Detects AdaptixC2 beacon via basic functions" reference = "https://github.com/Adaptix-Framework/AdaptixC2" strings: $FileTimeToUnixTimestamp = {D1 65 F8 83 7D F4 1F 7E 17 8B 55 E4} $Proxyfire_RecvProxy = {B9 FC FF 0F 00 E8 6A 04 00 00} $timeCalc1 = {8D 82 A0 05 00 00 89 44 24 3C EB 07} $timeCalc2 = {FF D2 0F B7 44 24 28 66 3B} $b64_encoded_size = {83 C0 01 39 45 18 7E 22 8B 45 E4 C1 E0 08 89 C1} $manage = {C6 44 24 5F 00 48 8B 45 10 48 8B 00} condition: any of them } |
AdaptixC2 Go Beacon
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
rule u42_hacktool_beaconGo_adaptixC2 { meta: description = "Detects AdaptixC2 beacon in GO via basic functions" reference = "https://github.com/Adaptix-Framework/AdaptixC2/tree/a7401fa3fdbc7ae6b632c40570292f844e40ff40/Extenders/agent_gopher" strings: $GetProcesses = {E8 96 4D E1 FF E8 96 4D E1 FF E8 96 4D E1 FF} $ConnRead = {0F 8E BD 00 00 00 4C 89 44 24 30 4C 89 54 24 40} $normalizedPath = {48 85 C9 74 0A 31 C0 31 DB 48 83 C4 38 5D C3 90 0F 1F 40 00} $Linux_GetOsVersion = {48 8D 05 51 D6 10 00 BB 0F 00 00 00} $Mac_GetOsVersion = {48 8D 05 AE 5A 0A 00 BB 30 00 00 00} condition: any of them } |
Cargador AdaptixC2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
rule u42_hacktool_adaptixC2_loader { meta: description = "Detects AdaptixC2 shellcode loader via API Hashing" reference = "https://github.com/Adaptix-Framework/AdaptixC2/blob/main/Extenders/agent_beacon/src_beacon/beacon/ApiDefines.h" strings: $hash_NtFlushInstructionCache = { 9E 65 A1 91 } $hash_VirtualAlloc = { 76 63 CE 63 } $hash_GetProcAddress = { DE 2A 4F 18 } $hash_LoadLibraryA = { FA D0 59 11} $Calc_Func_resolve_ApiFuncs = {06 00 00 0F B6 11 48 FF C1 85 D2 74 14 44 8D 42} condition: ( $hash_NtFlushInstructionCache and $hash_VirtualAlloc and $hash_GetProcAddress and $hash_LoadLibraryA ) or ( $Calc_Func_resolve_ApiFuncs ) } |
Normas de caza
- Descripción de la consulta: La siguiente consulta XQL busca actividades de phishing realizadas a través de la aplicación Teams que conducen a la ejecución de RMM. Estos atributos suelen ser el objetivo de los atacantes para implementar balizas AdaptixC2.
- Notas de la investigación: Comience por comprobar el título de la sesión de usuario. Busque la ejecución de la herramienta RMM y la creación de procesos secundarios o archivos mediante la herramienta RMM. Busque alertas o ejecuciones sospechosas, como cmd o PowerShell, por parte del usuario comprometido (actor_effective_username).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
config case_sensitive = false | dataset=xdr_data | fields _time as TeamsTime ,event_type,agent_hostname,actor_effective_username,event_sub_type, title, actor_process_image_name as teams_image_name, actor_process_image_sha256 , actor_process_image_command_line, agent_hostname, _time, action_process_image_name, agent_os_type, agent_id | filter agent_os_type = ENUM.AGENT_OS_WINDOWS and event_type = ENUM.USER_SESSION and teams_image_name in ("ms-teams.exe","updater.exe") and ((title contains "(external)" and title not contains "Chat |" ) and (title contains "help" )) | join type = inner ( dataset=xdr_data | fields _time as RmmStartTime ,agent_os_type , action_file_extension , event_type,agent_hostname,actor_effective_username,event_sub_type, actor_process_image_name , action_process_image_path, agent_hostname, action_process_image_name, agent_id, event_id | filter agent_os_type = ENUM.AGENT_OS_WINDOWS and (event_type=ENUM.PROCESS and event_sub_type = ENUM.PROCESS_START and action_process_image_name in ("*quickassist.exe","*anydesk.exe","*screenconnect.*.exe","*logmein.exe")) ) as rmm rmm.agent_id = agent_id and rmm.actor_effective_username = actor_effective_username and (timestamp_diff(rmm.RmmStartTime,TeamsTime , "MINUTE") < 10 and timestamp_diff(rmm.RmmStartTime,TeamsTime , "MINUTE") >= 0) | comp values(TeamsTime) as _time ,values(RmmStartTime) as RmmStartTime, values(teams_image_name) as teams_image_name, values(action_process_image_path) as action_process_image_name, values(actor_process_image_name) as ActorProcess, count(Title) as CountOfTitle by title,actor_effective_username,agent_hostname , agent_id, event_id | filter (array_length(action_process_image_name)>0) |
Ejemplo de extractor de configuración
El siguiente código es un ejemplo de un extractor de configuraciones que extrae configuraciones de archivos de balizas HTTP.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 |
import struct import json import sys from typing import Dict, Any from malduck import procmempe, rc4, int32, enhex class ConfigParser: def __init__(self, data: bytes): self.data = data self.offset = 0 def unpack32(self) -> int: value = struct.unpack('<I', self.data[self.offset:self.offset + 4])[0] self.offset += 4 return value def unpack16(self) -> int: """Unpack a 16-bit unsigned integer (little-endian)""" value = struct.unpack('<H', self.data[self.offset:self.offset + 2])[0] self.offset += 2 return value def unpack8(self) -> int: """Unpack an 8-bit unsigned integer""" value = self.data[self.offset] self.offset += 1 return value def unpack_string(self) -> str: """Unpack a length-prefixed string""" length = self.unpack32() string_data = self.data[self.offset:self.offset + length] self.offset += length if string_data and string_data[-1] == 0: string_data = string_data[:-1] return string_data.decode('utf-8', errors='replace') def unpack_bytes(self, length: int) -> bytes: """Unpack a fixed number of bytes""" data = self.data[self.offset:self.offset + length] self.offset += length return data def parse_beacon_http_config(data: bytes) -> Dict[str, Any]: """Parse BEACON_HTTP configuration from raw bytes""" parser = ConfigParser(data) config = {} try: # Parse agent type config['agent_type'] = parser.unpack32() # Parse HTTP profile config['use_ssl'] = bool(parser.unpack8()) config['servers_count'] = parser.unpack32() # Parse servers and ports config['servers'] = [] config['ports'] = [] for i in range(config['servers_count']): server = parser.unpack_string() port = parser.unpack32() config['servers'].append(server) config['ports'].append(port) # Parse HTTP settings config['http_method'] = parser.unpack_string() config['uri'] = parser.unpack_string() config['parameter'] = parser.unpack_string() config['user_agent'] = parser.unpack_string() config['http_headers'] = parser.unpack_string() # Parse answer sizes config['ans_pre_size'] = parser.unpack32() ans_size_raw = parser.unpack32() config['ans_size'] = ans_size_raw + config['ans_pre_size'] # Parse timing settings config['kill_date'] = parser.unpack32() config['working_time'] = parser.unpack32() config['sleep_delay'] = parser.unpack32() config['jitter_delay'] = parser.unpack32() # Default values from constructor config['listener_type'] = 0 config['download_chunk_size'] = 0x19000 return config except Exception as e: print(f"Failed to parse configuration: {e}") raise def parse_config(data: bytes, beacon_type: str = "BEACON_HTTP") -> Dict[str, Any]: """Main entry point for parsing beacon configurations""" if beacon_type == "BEACON_HTTP": return parse_beacon_http_config(data) else: raise NotImplementedError(f"Parser for {beacon_type} not implemented") if __name__ == "__main__": if len(sys.argv) < 2: print("Usage: python extractor.py <path_to_config_file>") sys.exit(1) passed_arg = sys.argv[1] try: sample = procmempe.from_file(passed_arg) rdata_section = sample.pe.section(".rdata") config_structure = sample.readp(rdata_section.PointerToRawData, rdata_section.SizeOfRawData) config_size = int32(config_structure) encrypted_config = config_structure[4:config_size+4] rc4_key = config_structure[config_size + 4 : config_size + 4 + 16] except Exception as e: print(f"Error reading file or extracting configuration: {e}") print("Using provided encrypted configuration bytes directly.") try: config_structure = bytes.fromhex(passed_arg) config_size = int32(config_structure) encrypted_config = config_structure[4:config_size+4] rc4_key = config_structure[config_size + 4 : config_size + 4 + 16] except Exception as e: print(f"Failed to process provided argument as configuration bytes: {e}") sys.exit(1) try: decrypted_config = rc4(rc4_key, encrypted_config) print(f"Decrypted configuration size: {len(decrypted_config)} bytes") print(f"Decrypted configuration content: {decrypted_config}") print("Decrypted configuration (hex): %s", enhex(decrypted_config)) config = parse_config(decrypted_config) print("Parsed configuration:") print(json.dumps(config, indent=2)) except Exception as e: print(f"Error parsing configuration: {e}") |
Recursos adicionales
- AdaptixC2: GitHub
- Fog Ransomware: Conjunto de herramientas inusuales utilizadas en un ataque reciente: Symantec
- Informe de respuesta ante incidentes de Unit 42 de 2025: Edición de ingeniería social: Unit 42
- Qué es el phishing: Palo Alto Networks
- Qué es RMM: ManageEngine
- Qué son los ataques de malware sin archivo: Palo Alto Networks
- Técnicas de secuestro de DLL: Unit 42
- Unit 42 desarrolla un marco de ataque de IA autónoma: Palo Alto Networks
- Método Marshal.GetDelegateForFunctionPointer: Microsoft Docs
- Invoke-RestMethod (PowerShell): Microsoft Docs
- Función VirtualProtect: Microsoft Docs
- Constantes de protección de memoria: Microsoft Docs
- MITRE ATT&CK T1547.001: MITRE