DarkGate Décrypté

Résumé

DarkGate est un chargeur basé sur Delphi vendu sous forme de Malware-as-a-Service sur les marchés criminels. Il inclut une fonctionnalité complète de RAT, une résolution d’API dynamique et des astuces d’évasion en couches telles que des jeux de caractères base64 personnalisés, style Union-API appel système chargement, et injection APC. L’outil, attribué au vendeur « RastaFarEye », a été adopté par des acteurs comme TA577 et Ducktail. Il communique avec le C2 sur HTTP avec des charges utiles obfusquées et peut déployer des utilitaires de bureau à distance, voler des jetons Discord et exécuter un shell inversé interactif.

Analyse de DarkGate Malware

La publication offre une explication détaillée par ingénierie inverse de l’exécutable de DarkGate, expliquant son brouillage de configuration sur mesure, sa génération de BotID pilotée par XOR, et son journalisation chiffrée. Elle catalogue les techniques de persistance du chargeur, les chemins d’escalade de privilèges, les flux de vol de jetons et l’abus de binaires légitimes tels que PsExec et Extexport pour le chargement de DLL. Le document décrit en outre les schémas de communication C2, les identifiants hVNC par défaut, et les ports HTTP typiques exploités (2351 et 9999).

Atténuation

Les équipes de sécurité doivent surveiller la création des fichiers référencés et des entrées de Registre Run, invalider ou bloquer immédiatement les identifiants hVNC par défaut, et détecter l’utilisation de PsExec et d’Extexport pour le chargement de DLL non approuvé. Les analyses comportementales doivent couvrir l’utilisation des appels système Union-API, l’injection APC via NtTestAlert, et le spoofing de PID parent. Les défenses réseau peuvent identifier des ports HTTP étranges et essayer de décoder les alphabets base64 personnalisés de DarkGate pour faire ressortir le trafic C2.

Réponse

Une fois l’activité de DarkGate confirmée, isolez le point d’extrémité affecté, récupérez les artefacts documentés, terminez les processus malveillants et nettoyez tous les points de persistance. Faites tourner tous les identifiants exposés et bloquez les domaines et plages IP connus du C2. Un examen médico-légal approfondi doit identifier toute charge utile secondaire et vérifier que toutes les DLL introduites via Extexport ou des chargeurs similaires ont été éradiquées.

Exécution de Simulation

Prérequis : le contrôle préalable de télémétrie et de base doit avoir été réussi.

• Narrative d’attaque et commandes :
  L’adversaire simulé a déjà infiltré le point d’extrémité et cherche à établir un accès RDP persistant. D’abord, ils récoltent les identifiants en les stockant avec cmdkey, puis utilisent psexec.exe pour se déplacer latéralement et enfin lancer une charge utile PowerShell qui dépose un enregistreur de frappe. Chaque étape est conçue pour générer les événements de création de processus exacts que la règle de détection surveille.

  1. Collecte d’identifiants (T1552.001) – Stocker une entrée d’identifiant conçue qui correspond au sélection_cmdkey de la règle.
  2. Mouvement latéral (T1219) – Exécuter psexec.exe contre un hôte distant, invoquant une commande qui engendre une nouvelle session PowerShell.
  3. Exécution PowerShell (T1059.001) – Lancer une commande PowerShell qui charge un script malveillant (simulé ici par une commande inoffensive encodée en base64).
  4. Déploiement de l’enregistreur de frappe (T1056.001) – Compiler et exécuter un petit binaire C qui appelle GetAsyncKeyState, générant la correspondance de champ API.

• Script de test de régression :

  # Script de simulation DarkGate – PowerShell
  # --------------------------------------------------
  # 1. Entrée d'identifiant cmdkey (correspond au modèle de détection)
  $generic = '""'                         # générique vide comme utilisé par DarkGate
  $user    = 'SafeMode'                   # nom d'utilisateur attendu par la règle
  $pass    = 'darkgatepassword0'          # mot de passe attendu par la règle
  cmd.exe /c cmdkey /generic:$generic /user:$user /pass:$pass
  
  # 2. Mouvement latéral PsExec (le binaire doit exister dans le PATH ou spécifier le chemin complet)
  $remoteHost = '10.0.0.5'
  $psexecPath = "$env:SystemRootSystem32psexec.exe"
  if (Test-Path $psexecPath) {
      & $psexecPath \$remoteHost -accepteula cmd /c "whoami"
  } else {
      Write-Host "PsExec non trouvé à $psexecPath – étape sautée."
  }
  
  # 3. Exécution PowerShell (commande inoffensive encodée en base64)
  $psCommand = 'Write-Output "Charge utile PowerShell exécutée"'
  $encoded = [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($psCommand))
  powershell.exe -EncodedCommand $encoded
  
  # 4. Compilation et exécution du stub de keylogger
  $cSource = @"
  #include <windows.h>
  int main() {
      // Simple appel à GetAsyncKeyState pour satisfaire la correspondance API
      GetAsyncKeyState(VK_RETURN);
      return 0;
  }
  "@
  $srcPath = "$env:TEMPkeylog_stub.c"
  $exePath = "$env:TEMPkeylog_stub.exe"
  $cSource | Set-Content -Path $srcPath -Encoding ASCII
  # Compiler avec Visual C++ (cl.exe doit être dans le PATH)
  cl.exe /nologo /O2 /Fe:$exePath $srcPath
  if (Test-Path $exePath) {
      & $exePath
  }

• Commandes de nettoyage :

  # Supprimer l'entrée d'identifiant
  cmd.exe /c cmdkey /delete:$generic
  
  # Supprimer les fichiers temporaires
  Remove-Item -Force -ErrorAction SilentlyContinue "$env:TEMPkeylog_stub.c"
  Remove-Item -Force -ErrorAction SilentlyContinue "$env:TEMPkeylog_stub.exe"
  
  # Optionnel : terminer tous les processus psexec ou powershell lancés par le script
  Get-Process -Name psexec, powershell -ErrorAction SilentlyContinue | Stop-Process -Force