Dentro do Vidar 2026: Da Infecção à Execução na Memória

Resumo

O relatório examina como o Vidar evoluiu para uma estrutura de ataque sem arquivos e em múltiplas etapas que combina carregadores baseados em Go, VBS, PowerShell e binários living-off-the-land para recuperar conteúdo malicioso oculto dentro de arquivos JPEG e TXT hospedados em um endereço IP remoto. As cargas inseridas são extraídas, decodificadas e executadas diretamente na memória através de RegAsm.exe, evitando a detecção baseada em disco. O acesso inicial é realizado por meio de iscas de engenharia social, como repositórios falsos do GitHub, sites WordPress comprometidos e páginas CAPTCHA falsas. A campanha também utiliza domínios com front-end no Telegram e Cloudflare para comando e controle, além de exfiltração de dados.

Investigação

Pesquisadores do Point Wild rastrearam toda a corrente de infecção desde o inicializador compilado em Go até a carga final do Vidar, documentando cada camada de obfuscação ao longo do caminho. Sua análise destacou o uso de marcadores customizados Base64, strings invertidas e carregamento reflexivo de .NET assemblies para ocultar a execução. Os pesquisadores também descreveram como WScript, PowerShell e RegAsm.exe foram abusados como proxies de execução, permitindo ao malware decodificar e lançar uma DLL oculta inteiramente na memória. O tráfego de rede também confirmou a recuperação via HTTP das cargas JPEG e TXT em fases, a partir de um endereço IP codificado.

Mitigação

Os defensores devem se concentrar em detectar os estágios iniciais de VBS e PowerShell da cadeia de infecção, incluindo o uso suspeito de RegAsm.exe, recuperação de arquivos JPEG ou TXT do IP malicioso e padrões reconhecíveis de marcadores Base64. Bloquear domínios e endereços IP maliciosos conhecidos, monitorar o tráfego de saída para o Telegram e aplicar controles de execução às utilidades comuns LOLBin pode ajudar a reduzir a exposição. A detecção baseada em comportamento ajustada para execução sem arquivos e técnicas de carregamento na memória também é fortemente recomendada.

Resposta

Se forem identificados indicadores ligados à cadeia de infecção do Vidar, isole imediatamente o host afetado, termine processos suspeitos como WScript, PowerShell e RegAsm.exe, e colete imagens de memória para revisão forense. O endereço IP identificado e os domínios relacionados devem ser bloqueados, e quaisquer atalhos de inicialização ou tarefas agendadas usadas para persistência devem ser removidos. As equipes de segurança também devem realizar uma revisão completa de credenciais focada em dados expostos de navegadores, extensões e carteiras de criptomoedas.

Execução de Simulação

Pré-requisito: A Verificação de Pré-Voo de Telemetria & Baseline deve ter sido aprovada.

Racional: Esta seção detalha a execução precisa da técnica do adversário (TTP) destinada a acionar a regra de detecção. Os comandos e a narrativa DEVEM refletir diretamente os TTPs identificados e visam gerar exatamente a telemetria esperada pela lógica de detecção.

• Narrativa e Comandos de Ataque:

  1. Distribuidor Inicial (WScript): O atacante entrega um arquivo JScript malicioso (payload.js) que é lançado via WScript.exe. O script baixa uma carga de PowerShell codificada em base64 de um servidor C2 e a escreve em %TEMP%.
  2. Estágio PowerShell: A carga baixada é executada com -ExecutionPolicy Bypass -NoProfile -WindowStyle Hidden, realiza o carregamento reflexivo de DLL (T1620) de um assembly .NET malicioso (evil.dll) na memória, e armazena o assembly em disco.
  3. Proxy RegAsm: Para evitar a detecção nativa do PowerShell, o atacante invoca RegAsm.exe apontando para evil.dll com o /codebase interruptor, causando a execução do ponto de entrada malicioso pelo carregador .NET (T1574.014).

  A cadeia cria três eventos Sysmon distintos—cada um correspondendo ao Image|endswith seletor da regra—acionando, assim, o alerta.

• Script de Teste de Regressão: O script abaixo reproduz a cadeia acima de forma segura, em sandbox , usando comandos echo inofensivos e um DLL fictício (um simples arquivo de texto) para evitar atividade maliciosa real, enquanto ainda gera os mesmos eventos de criação de processo.

  <#  
  Simulação de execução em múltiplas etapas no estilo Vidar  
  - Estágio 1: WScript lança um JScript que escreve um script PowerShell em %TEMP%  
  - Estágio 2: PowerShell executa o script, cria um DLL fictício e lança RegAsm  
  #>
  
  # ---------- Estágio 1: WScript ----------
  $jsPath = "$env:TEMPstage1.js"
  $psPayloadPath = "$env:TEMPstage2.ps1"
  $dummyDllPath = "$env:TEMPevil.dll"
  
  # JScript que escreve uma carga de PowerShell simples para disco
  $jsContent = @"
  var fso = new ActiveXObject("Scripting.FileSystemObject");
  var ts = fso.OpenTextFile("$psPayloadPath", 2, true);
  ts.WriteLine('Write-Host "[Stage 2] PowerShell executado"');
  ts.WriteLine('Set-Content -Path "$dummyDllPath" -Value "Este é um DLL fictício"');
  ts.WriteLine('Start-Process -FilePath "$env:SystemRootMicrosoft.NETFramework64v4.0.30319RegAsm.exe" -ArgumentList "`"$dummyDllPath`" /codebase" -NoNewWindow');
  ts.Close();
  "@
  
  Set-Content -Path $jsPath -Value $jsContent -Encoding ASCII
  
  # Executar o JScript via WScript
  Write-Host "`n[Stage 1] Iniciando WScript..."
  & "$env:SystemRootSystem32WScript.exe" $jsPath
  
  # ---------- Estágio 2: PowerShell ----------
  Write-Host "`n[Stage 2] Executando carga de PowerShell gerada..."
  & powershell.exe -NoProfile -ExecutionPolicy Bypass -File $psPayloadPath
  
  # ---------- Limpeza ----------
  Write-Host "`nLimpando arquivos temporários..."
  Remove-Item -Path $jsPath, $psPayloadPath, $dummyDllPath -Force -ErrorAction SilentlyContinue

• Comandos de Limpeza: Além da limpeza no final do script, execute o seguinte para garantir que nenhum processo ou arquivo remanescente permaneça.

  # Termine à força quaisquer instâncias de RegAsm ou PowerShell deixadas pelo teste
  Get-Process -Name regasm, powershell -ErrorAction SilentlyContinue | Stop-Process -Force
  
  # Remova quaisquer arquivos residuais em %TEMP% que correspondam ao padrão do teste
  Get-ChildItem -Path $env:TEMP -Filter "stage*.*" -File | Remove-Item -Force