Avant-propos
Au début du mois de mai 2025, les chercheurs de Unit 42 ont constaté qu’AdaptixC2 était utilisé pour infecter plusieurs systèmes.
AdaptixC2 est un framework open source récemment identifié, conçu pour la post-exploitation et l’émulation malveillante à destination de testeurs de pénétration, mais déjà utilisé par des acteurs de la menace dans leurs campagnes. Contrairement à de nombreux frameworks C2 bien connus, AdaptixC2 est resté en grande partie inaperçu. Il existe peu de documents publics démontrant son utilisation dans le cadre d’attaques réelles. Nos recherches analysent les capacités d’AdaptixC2, afin d’aider les équipes de sécurité à s’en protéger.
AdaptixC2 est un framework polyvalent de post-exploitation. Les acteurs de la menace l’utilisent pour exécuter des commandes, transférer des fichiers et exfiltrer des données sur des systèmes compromis. Comme il s’agit d’un logiciel open source, les acteurs de la menace peuvent facilement le personnaliser et l’adapter à leurs objectifs spécifiques. Cela en fait un outil extrêmement flexible et dangereux.
L’émergence d’AdaptixC2 comme outil utilisé sur le terrain par des acteurs de la menace souligne une tendance croissante des attaquants à recourir à des frameworks personnalisables pour échapper à la détection.
Les clients de Palo Alto Networks sont mieux protégés contre les menaces décrites dans cet article grâce aux produits suivants :
- Advanced DNS Security
- Advanced Threat Prevention
- Advanced URL Filtering
- Advanced WildFire
- Cortex XDR et XSIAM
Si vous pensez que votre entreprise a pu être compromise ou si vous faites face à une urgence, contactez l’équipe Unit 42 de réponse à incident.
Unit 42 – Thématiques connexes | Pentesting Tools, C2 |
Analyse technique du framework malveillant AdaptixC2
AdaptixC2 est un framework C2 open source que nous avons récemment observé utilisé dans plusieurs attaques réelles.
Nous avons identifié deux infections par AdaptixC2. Dans un cas, des techniques d’ingénierie sociale ont été exploitées. Nous estimons avec une grande certitude que l’autre a utilisé des outils de génération de code basés sur l’IA.
Fonctionnalités d’AdaptixC2
AdaptixC2 est un outil de red teaming pouvant être exploité pour mener des actions malveillantes, avec des possibilités d’extension et de personnalisation. S’il était utilisé par un acteur de la menace, il pourrait prendre le contrôle complet des machines compromises et exécuter un large éventail d’actions. Par exemple :
- Manipulation du système de fichiers
- Répertoires de listes
- Création, modification et suppression de fichiers et de dossiers
- Énumération des processus en cours d’exécution
- Fermeture de certaines applications spécifiques
- Lancement des exécutions de nouveaux programmes
Les acteurs de la menace utilisent ces fonctionnalités pour établir et maintenir une présence dans un environnement, explorer davantage le système compromis et se déplacer latéralement au sein du réseau.
Pour faciliter des communications discrètes et contourner les restrictions réseau, le framework prend en charge des fonctionnalités de tunneling sophistiquées, y compris la fonctionnalité de proxy SOCKS4/5 et le transfert de ports. Cela permet aux attaquants de maintenir des canaux de communication même si le réseau est fortement protégé.
AdaptixC2 est conçu de manière modulaire, utilisant des « extenders » qui fonctionnent comme des plug-in pour les auditeurs et les agents. Cela permet aux pirates de créer des payloads personnalisés et des moyens d’éviter la détection qui sont spécifiques au système qu’ils attaquent. AdaptixC2 prend également en charge les Beacon Object Files (BOF), qui permettent aux attaquants d’exécuter de petits programmes personnalisés écrits en C directement dans le processus de l’agent afin d’échapper à la détection.
Les agents Beacon d’AdaptixC2 sont équipés de commandes dédiées pour transférer des données rapidement et secrètement. Ces agents sont compatibles avec les architectures x86 et x64, et peuvent être générés dans différents formats, notamment :
- Fichiers exécutables autonomes (EXE)
- Fichiers BBL (bibliothèque à liaisons dynamiques)
- Fichiers exécutables de service
- Shellcode brut
Les attaquants peuvent utiliser le framework AdaptixC2 pour dérober des données sur le réseau compromis. Cette fonctionnalité d’exfiltration de données permet de configurer la taille des segments pour les téléchargements et les chargements de fichiers, les segments plus petits étant moins susceptibles d’être détectés par les systèmes de surveillance réseau.
L’interface AdaptixC2 affiche les agents et les sessions liés sous forme de vue graphique. La figure 1 illustre la vue de l’attaquant, montrant la progression des attaques multi-étapes et les chemins disponibles pour se déplacer dans le réseau ciblé.

AdaptixC2 comprend également des fonctionnalités qui aident l’attaquant à maintenir la sécurité opérationnelle (OpSec). Il s’agit notamment de paramètres qui leur permettent de se fondre dans le trafic réseau normal :
- KillDate : définit la date à laquelle le beacon cessera de fonctionner.
- WorkingTime : cette option permet au beacon de n’être actif que pendant certaines heures.
En outre, les acteurs de la menace peuvent modifier et améliorer l’agent en utilisant des techniques personnalisées d’obscurcissement, d’anti-analyse et d’évasion, ce qui en fait une menace en constante évolution.
Configuration
La configuration d’AdaptixC2 est chiffrée et prend en charge trois types de beacons primaires grâce à des structures de profil spécialisées :
- BEACON_HTTP pour les communications basées sur le web
- BEACON_SMB pour la communication par canal nommé
- BEACON_TCP pour les connexions TCP directes
Le profil HTTP est la variante du beacon la plus courante et contient des paramètres de communication web typiques tels que :
- Serveurs
- Ports
- Paramètres SSL
- Méthodes HTTP
- URI
- En-têtes
- Chaînes d’agents utilisateurs
Le profil SMB utilise les canaux nommés de Windows lorsque le protocole HTTP peut être bloqué ou surveillé. Le profil TCP est utilisé pour créer des connexions de socket directes avec la possibilité d’ajouter des données pour un obscurcissement de base du protocole.
AdaptixC2 comprend une configuration par défaut intégrée, montrant comment le framework est généralement déployé et utilisé en conditions réelles. Le profil HTTP par défaut cible 172.16.196.1:4443 en utilisant une communication HTTPS, avec une méthode POST vers le terminal /uri.php et le paramètre X-Beacon-Id pour l’identification du beacon.
La figure 2 explique comment configurer le beacon.

Après avoir cliqué sur « Create », le générateur de beacon chiffre la configuration avec l’algorithme cryptographique RC4 avant de l’intégrer dans le beacon compilé. La configuration chiffrée est stockée comme suit :
- 4 octets : Taille de la configuration (entier 32 bits)
- n octets : Données de configuration chiffrées RC4
- 16 octets : Clé de chiffrement RC4
Le code suivant est la logique d’extraction des clés, extrait 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); |
Extraction de la configuration à partir d’échantillons malveillants
Le cryptage étant simple et prévisible, les équipes de sécurité peuvent développer un outil qui extrait automatiquement les configurations des échantillons. Cet outil d’extraction devrait fonctionner de la même manière que le beacon charge ses propres configurations.
L’outil d’extraction localise la configuration dans la section .rdata du fichier PE. Il extrait ensuite la taille (quatre premiers octets), le bloc de données chiffrées et la clé RC4 (16 derniers octets). Après avoir utilisé la clé RC4 intégrée pour déchiffrer les données, il analyse la configuration en texte clair en décomposant les champs suivants :
- Type d’agent
- Indicateur SSL
- Nombre de serveurs
- Serveurs/ports
- Paramètres HTTP
- Paramètres de synchronisation
En utilisant cette méthode, nous avons créé un outil qui peut traiter les échantillons AdaptixC2 et obtenir leurs configurations intégrées. Le code complet de l’outil d’extraction prend en charge la variante BEACON_HTTP. Cet outil est fourni dans la section Exemple d’extracteur de configuration. Les chercheurs peuvent utiliser cet extracteur pour analyser les échantillons AdaptixC2 ou adapter le code à d’autres variantes.
La configuration par défaut du beacon est décrite ci-dessous.
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 } |
Scénarios d’utilisation d’AdaptixC2
Scénario 1 : Un appel frauduleux au service d’assistance mène à une infection par AdaptixC2
En mai 2025, nous avons enquêté sur plusieurs incidents au cours desquels des acteurs de la menace ont installé des beacons AdaptixC2. Dans certains cas, nous avons observé que les acteurs de la menace utilisaient le même vecteur d’attaque, comme indiqué à la figure 3.

Compromission initiale
Les acteurs de la menace ont exploité la confiance accordée à Microsoft Teams pour inciter les utilisateurs à leur donner accès aux systèmes de l’entreprise. Dans un cas, les attaquants ont utilisé des attaques d’hameçonnage pour se faire passer pour du personnel d’assistance informatique (en utilisant des lignes d’objet telles que « Help Desk (External) | Microsoft Teams »). Cela a convaincu les employés de lancer des sessions légitimes d’assistance à distance à l’aide d’outils tels que Quick Assist, l’outil de surveillance et de gestion à distance (RMM).
Ce type d’usurpation est courant chez les acteurs de la menace et ne reflète en aucun cas une faille dans les produits ou services des éditeurs concernés. Cela n’implique pas nécessairement une faille ou une qualité malveillante du produit légitime utilisé à mauvais escient.
Le Rapport mondial 2025 de Unit 42 sur la réponse à incident : L’édition « Social Engineering » a noté que des techniques comme celle-ci constituent le vecteur d’accès initial le plus répandu dans les compromissions que nous observons. Cet accès initial permet aux attaquants de prendre pied dans le système ciblé, sans qu’ils aient besoin de contourner les défenses périmétriques comme les pare-feu ou les systèmes de détection d’intrusion.
Déploiement et persistance d’AdaptixC2 via l’exécution d’un shellcode
Les attaquants ont déployé le beacon AdaptixC2 à l’aide d’un chargeur PowerShell en plusieurs étapes qui télécharge un payload codé et chiffré à partir d’un lien vers un service légitime.
Une fois téléchargé, le script PowerShell déchiffre le payload à l’aide d’une simple clé XOR. Au lieu d’écrire le payload déchiffré sur le disque, ce qui le rendrait plus facile à détecter, le script exploite les capacités de .NET pour allouer de la mémoire au sein du processus PowerShell lui-même. Le script copie ensuite le payload déchiffré, qui est en fait un shellcode, dans cette région de mémoire allouée. Cette approche sans fichier réduit considérablement l’empreinte laissée par l’attaquant sur le système.

Le script utilise une technique appelée « invocation dynamique » pour exécuter le shellcode directement depuis la mémoire. Pour ce faire, il utilise la fonction GetDelegateForFunctionPointer qui crée dynamiquement un délégué (un pointeur de fonction typé) qui pointe vers le début du shellcode en mémoire. Le script appelle ensuite ce délégué comme s’il s’agissait d’une fonction normale, ce qui permet d’exécuter le shellcode sans écrire de fichier exécutable sur le disque. Pour garantir le lancement automatique du processus malveillant après le redémarrage, le script crée un raccourci dans le dossier de démarrage. La figure 4 présente le script PowerShell.

La variante de beacon chargée dans cette attaque avait la configuration suivante :
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 } |
Activité post-exploitation et confinement
Après le déploiement réussi d’AdaptixC2, les attaquants ont lancé des activités de reconnaissance, utilisant des outils en ligne de commande pour recueillir des informations sur les systèmes et le réseau compromis. Il s’agit notamment de commandes de découverte telles que nltest.exe, whoami.exe et ipconfig.exe.
Le beacon a ensuite établi une communication avec un serveur distant, permettant aux acteurs de la menace d’obtenir un lien C2 sur la machine infectée.
Scenario 2 : Infection due à un script généré par l’IA
Dans un autre cas, les acteurs de la menace ont utilisé un script PowerShell conçu pour déployer des beacons AdaptixC2. Nous évaluons avec une grande confiance que ce script a été généré par l’IA. Ce déploiement a été réalisé à la fois par l’injection de shellcode en mémoire et à l’aide d’un mécanisme de persistance du détournement de fichiers DLL. Le script, illustré à la figure 5, s’efforce de rester dissimulé sur le système infecté afin de donner aux pirates un point d’ancrage solide.

Analyse détaillée du PowerShell généré par l’IA
- Téléchargement et décodage du shellcode : Le script télécharge un payload de shellcode codé en Base64 à partir d’un serveur distant à l’aide de la méthode Invoke-RestMethod. Le contenu téléchargé est ensuite décodé.
- Allocation de mémoire, copie de shellcode et modification de la protection de la mémoire : Le script alloue un bloc de mémoire non géré. Le shellcode AdaptixC2 est ensuite copié dans la mémoire allouée et modifie les attributs de protection de cette zone de mémoire sont modifiés via VirtualProtect en 0x40 (PAGE_EXECUTE_READWRITE). Cela permet d’exécuter le shellcode.
- Exécution d’un shellcode par invocation dynamique : Comme dans le cas précédent, l’attaquant a utilisé GetDelegateForFunctionPointer pour créer une instance de délégué pointant vers le début du shellcode en mémoire. L’attaquant a ensuite utilisé la méthode Invoke() pour exécuter le shellcode et lancer le beacon en mémoire.
- Persistance du détournement de fichiers DLL : Le script cible le répertoire APPDATA\Microsoft\Windows\Templates pour le détournement de fichiers DLL, en utilisant msimg32.dll. Ce fichier DLL est également une version de beacon.
- Persistance via la clé run de registre Run : Le script crée une entrée dans la clé de registre Run nommée « Updater », contenant une commande PowerShell qui exécute le script loader.ps1. Cela garantit que le script loader.ps1 s’exécute à chaque connexion de l’utilisateur, lançant ainsi le beacon.
Génération de scripts d’IA
La structure et la composition de ce script PowerShell suggèrent fortement que l’attaquant a utilisé des techniques de génération assistée par l’IA. Les éléments stylistiques suivants sont couramment observés dans le code généré par les outils d’IA :
- Commentaires détaillés et numérotés :
- "# === [1] Download and decode shellcode ==="
- Icônes cochées dans le message de sortie :
- Write-Output "[✔] Persistence set via Run key and DLL hijack DLL dropped to $templatesPath"
Nous évaluons avec une grande certitude que le code a été généré avec l’aide de l’IA. Ce résultat est basé sur les facteurs susmentionnés, ainsi que sur les preuves recueillies sur le serveur de l’attaquant et les résultats extraits de deux détecteurs d’IA distincts.
Les outils d’IA sans garde-fous suffisants peuvent permettre aux attaquants de développer rapidement des codes malveillants, facilitant ainsi l’exécution d’opérations dans les réseaux infectés.
Similitudes entre les cas
Un schéma cohérent s’est dégagé de ces deux incidents :
- Chargeurs basés sur PowerShell
- Les acteurs de la menace ont utilisé ces chargeurs pour déployer le beacon AdaptixC2, en privilégiant la furtivité et l’accès persistant.
- Téléchargement d’un payload à partir d’un serveur distant et exécution en mémoire
- L’utilisation d’une ressource légitime a permis aux attaquants de rester inaperçus, en minimisant les traces détectables sur le disque.
- S’appuyer sur les capacités de .NET pour l’allocation de mémoire et l’invocation dynamique
- Les acteurs de la menace ont exploité les fonctionnalités intégrées du système, telles que la méthode GetDelegateForFunctionPointer pour exécuter du shellcode pour des raisons d’efficacité et de discrétion.
- Empêcher la suppression des beacons à l’aide de mécanismes de persistance
- Alors que le premier script se contentait d’utiliser un raccourci dans le dossier de démarrage pour assurer la persistance, le second a ajouté le détournement de fichiers DLL.
- Les attaquants disposent ainsi de plus de moyens pour rester sur le système compromis.
- Utilisation de conventions de dénomination similaires pour les scripts et les clés run
- Dans un cas, les attaquants ont nommé le script malveillant update.ps1. Dans un autre, la clé run pour la persistance s’appelait « Updater ».
- Cette dénomination permet aux scripts et aux clés de passer inaperçus dans les processus légitimes du système.
Popularité croissante du framework AdaptixC2
Notre télémétrie et nos renseignements sur les menaces montrent qu’AdaptixC2 est de plus en plus répandu. Nous continuons à identifier de nouveaux serveurs AdaptixC2, ce qui suggère que de plus en plus d’acteurs de la menace adoptent ce framework dans leur arsenal d’attaques.
Cette tendance s’étend au-delà des scénarios typiques de post-exploitation. Par exemple, les attaquants ont déployé le ransomware Fog en même temps qu’AdaptixC2 lors d’une récente attaque contre une institution financière en Asie. Cela montre qu’AdaptixC2 est polyvalent et peut être utilisé avec d’autres outils malveillants, comme les ransomwares, pour atteindre des objectifs plus larges.
Conclusion
AdaptixC2 est une menace adaptable, comme en témoignent sa popularité croissante auprès des acteurs de la menace et la complexité de ses techniques de déploiement. La modularité de ce framework, combinée au potentiel de génération de code assistée par l’IA, pourrait permettre aux acteurs de la menace de faire évoluer rapidement leurs tactiques. Les équipes de sécurité doivent rester conscientes des capacités d’AdaptixC2 et adapter leurs défenses de manière proactive pour contrer cette menace.
Les clients de Palo Alto Networks sont mieux protégés contre les menaces mentionnées ci-dessus grâce aux produits et services suivants :
- Advanced URL Filtering et Advanced DNS Security permettent d’identifier les domaines et URL associés à cette activité comme étant malveillants.
- Advanced Threat Prevention intègre une détection basée sur le machine learning pour identifier les exploits en temps réel.
- Les modèles de Machine Learning d’Advanced WildFire ont été mis à jour sur la base des indicateurs de compromission (IoC) identifiés dans cette recherche.
- Cortex XDR et XSIAM aident à prévenir les malwares à l’aide du moteur de prévention des malwares. Cette approche combine plusieurs couches de protection conçues pour empêcher les malwares connus et inconnus de nuire à vos terminaux. Les techniques d’atténuation utilisées par le moteur de prévention des malwares varient en fonction du type de terminal.
Si vous pensez que votre entreprise a pu être compromise ou si vous faites face à une urgence, contactez l’équipe Unit 42 de réponse à incident ou composez l’un des numéros suivants :
- Amérique du Nord : Gratuit : +1 (866) 486-4842 (866.4.UNIT42)
- Royaume-Uni : +44 20 3743 3660
- Europe et Moyen-Orient : +31.20.299.3130
- Asie : +65.6983.8730
- Japon : +81 50 1790 0200
- Australie : +61.2.4062.7950
- Inde : 00080005045107
Palo Alto Networks a partagé ces conclusions avec les autres membres de la Cyber Threat Alliance (CTA). Les membres de la CTA s’appuient sur ces renseignements pour déployer rapidement des mesures de protection auprès de leurs clients et perturber de manière coordonnée les activités des cybercriminels. Cliquez ici pour en savoir plus sur la Cyber Threat Alliance.
Indicateurs de compromission
Avantage | Type | Description |
bdb1b9e37f6467b5f98d151a43f280f319bacf18198b22f55722292a832933ab | SHA256 | Script PowerShell qui installe un beacon AdaptixC2 |
83AC38FB389A56A6BD5EB39ABF2AD81FAB84A7382DA296A855F62F3CDD9D629D | SHA256 | Script PowerShell qui installe un beacon AdaptixC2 |
19c174f74b9de744502cdf47512ff10bba58248aa79a872ad64c23398e19580b | SHA256 | Script PowerShell qui installe un beacon AdaptixC2 |
750b29ca6d52a55d0ba8f13e297244ee8d1b96066a9944f4aac88598ae000f41 | SHA256 | Script PowerShell qui installe un beacon AdaptixC2 |
b81aa37867f0ec772951ac30a5616db4d23ea49f7fd1a07bb1f1f45e304fc625 | SHA256 | Beacon AdaptixC2 sous forme de fichier DLL |
df0d4ba2e0799f337daac2b0ad7a64d80b7bcd68b7b57d2a26e47b2f520cc260 | SHA256 | Beacon AdaptixC2 sous forme de fichier EXE |
AD96A3DAB7F201DD7C9938DCF70D6921849F92C1A20A84A28B28D11F40F0FB06 | SHA256 | Shellcode qui installe le beacon AdaptixC2 |
tech-system[.]online | Domaine | Domaine AdaptixC2 |
protoflint[.]com | Domaine | Domaine AdaptixC2 |
novelumbsasa[.]art | Domaine | Domaine AdaptixC2 |
picasosoftai[.]shop | Domaine | Domaine AdaptixC2 |
dtt.alux[.]cc | Domaine | Domaine AdaptixC2 |
moldostonesupplies[.]pro | Domaine | Domaine AdaptixC2 |
x6iye[.]site | Domaine | Domaine AdaptixC2 |
buenohuy[.]live | Domaine | Domaine AdaptixC2 |
firetrue[.]live | Domaine | Domaine AdaptixC2 |
lokipoki[.]live | Domaine | Domaine AdaptixC2 |
veryspec[.]live | Domaine | Domaine AdaptixC2 |
mautau[.]live | Domaine | Domaine AdaptixC2 |
muatay[.]live | Domaine | Domaine AdaptixC2 |
nicepliced[.]live | Domaine | Domaine AdaptixC2 |
nissi[.]bg | Domaine | Domaine AdaptixC2 |
express1solutions[.]com | Domaine | Domaine AdaptixC2 |
iorestore[.]com | Domaine | Domaine AdaptixC2 |
doamin[.]cc | Domaine | Domaine AdaptixC2 |
regonalone[.]com | Domaine | Domaine AdaptixC2 |
Règles de Yara
Les équipes de sécurité peuvent utiliser ces règles Yara pour détecter la présence de beacons AdaptixC2 sur les machines.
Beacon HTTP/SMB/TCP 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 |
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 } |
Beacon Go d’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 |
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 } |
Chargeur 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 ) } |
Règles de chasse aux menaces
- Description de la requête : La requête XQL suivante recherche les activités d’hameçonnage menées via l’application Teams, qui conduisent à l’exécution d’outils RMM. Ces attributs sont généralement ciblés par les attaquants pour déployer les beacons AdaptixC2.
- Notes relatives à l’investigation : Commencez par vérifier l’intitulé de la session utilisateur. Recherchez l’exécution de l’outil RMM et la création d’un processus enfant ou d’un fichier à l’aide de l’outil RMM. Recherchez des alertes ou des exécutions suspectes telles que cmd ou PowerShell par l’utilisateur compromis (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) |
Exemple d’extracteur de configuration
Le code suivant est un exemple d’extracteur de configuration qui extrait les configurations des fichiers de beacons 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}") |
Pour aller plus loin
- AdaptixC2 – GitHub
- Ransomware Fog : Un ensemble d’outils inhabituels utilisés lors d’une récente attaque – Symantec
- Rapport mondial 2025 de Unit 42 sur la réponse à incident : édition spéciale sur l’ingénierie sociale – Unit 42
- Qu’est-ce que l’hameçonnage ? – Palo Alto Networks
- Qu’est-ce que l’outil RMM ? – ManageEngine
- Qu’est-ce qu’une attaque par malware sans fichier ? – Palo Alto Networks
- Techniques de détournement de fichiers DLL – Unit 42
- L’Unit 42 développe un framework d’attaque d’IA agentique – Palo Alto Networks
- Méthode Marshal.GetDelegateForFunctionPointer – Microsoft Docs
- Invoke-RestMethod (PowerShell) – Microsoft Docs
- Fonction VirtualProtect – Microsoft Docs
- Constantes de protection de la mémoire – Microsoft Docs
- MITRE ATT&CK T1547.001 – MITRE