ChainShell: MuddyWater & MaaS Russa

Resumo

MuddyWater, um ator de espionagem ligado ao Irã, está aproveitando a plataforma de malware como serviço TAG-150 russa para entregar CastleRAT e um novo agente de C2 habilitado por blockchain, baseado em Node.js, rastreado como ChainShell contra alvos israelenses e outros de alto valor. A atividade é suportada por um servidor web C2 exposto e mal configurado, um script de implantação PowerShell (reset.ps1) e cargas PE ocultas através de esteganografia. Várias versões do CastleRAT (incluindo Build 120 e Build 13) contêm identificadores codificados em hard que apontam para a mesma linhagem de MaaS. A infraestrutura de backend parece ser campanhizada, utilizando domínios compartilhados (por exemplo, serialmenot.com) e credenciais JWT por operação para separar o acesso e rastreamento em diferentes implantações.

Investigação

A JUMPSEC revisou o host C2 exposto, recuperou 15 amostras de malware e vinculou a lógica de implantação do reset.ps1 à entrega tanto do ChainShell quanto de várias versões do CastleRAT. Os investigadores também correlacionaram certificados de assinatura de código (Amy Cherne e Donald Gay) vistos em ferramentas conhecidas do MuddyWater com o instalador MSI TAG-150, formando uma trilha de atribuição de alta confiança. Foi observada sobreposição adicional entre amostras em marcadores de build codificados em hard, convenções de nomeação de tarefas agendadas recorrentes e IDs de campanha JWT incorporados nas ferramentas e artefatos do lado do servidor.

Mitigação

Monitore o reset.ps1, as tarefas agendadas associadas e artefatos de caminho de arquivo ou mutex únicos vinculados ao CastleRAT e ChainShell. Bloqueie a infraestrutura TAG-150 conhecida, incluindo serialmenot.com, ttrdomennew.com e sharecodepro.com, e examine a instalação de componentes Node.js acionada pelo PowerShell. Implemente controles rigorosos de assinatura de código e valide certificados suspeitos em relação a materiais de assinatura ligados ao MuddyWater.

Resposta

Se forem encontrados indicadores, isole os endpoints impactados, capture imagens completas de disco e memória e varra por remanescentes adicionais do CastleRAT e ChainShell. Revogue ou desconfie de certificados de assinatura de código comprometidos, redefina credenciais afetadas e coordene o relatório com os CERTs nacionais relevantes. Revise a telemetria de rede para padrões de acesso Ethereum RPC e uso de JWT vinculados ao fluxo de comando e controle do serialmenot.com.

Execução de Simulação

Pré-requisito: A Verificação Prévia de Telemetria e Linha de Base deve ter passado.

• Narrativa do Ataque e Comandos:

  1. Etapa 1 – Preparar um servidor C2 simples (executar na máquina do atacante ou uma VM controlada). O servidor escuta na porta 9999 e ecoa dados recebidos.

  2. Etapa 2 – No host de destino Windows, iniciar uma backdoor PowerShell que abre uma conexão TCP com o servidor C2 na porta 9999. A carga útil usa classes nativas do .NET para evitar criar um executável separado, imitando uma abordagem “viver da terra”.

  3. Etapa 3 – Hop de proxy opcional: O script PowerShell primeiro contacta um proxy HTTP local (escutando em 127.0.0.1:8080) que encaminha o tráfego TCP para o servidor C2 remoto, demonstrando que a porta de destino permanece inalterada.

  Essas etapas produzem eventos de firewall com DestinationPort = 9999, satisfazendo a regra Sigma.

• Script de Teste de Regressão:

  # -------------------------------------------------
  # Simulação C2 estilo CastleRAT – PowerShell
  # -------------------------------------------------
  # 1. Definir endereço do servidor C2 (substituir pelo seu IP de teste)
  $c2Ip = "10.0.0.50"
  $c2Port = 9999
  
  # 2. OPCIONAL: Definir proxy local (se quiser testar hop de proxy)
  $useProxy = $false
  $proxyHost = "127.0.0.1"
  $proxyPort = 8080
  
  # 3. Função para abrir um stream TCP (direto ou via proxy)
  function Invoke-C2Connection {
      param (
          [string]$destIp,
          [int]$destPort,
          [bool]$viaProxy
      )
      if ($viaProxy) {
          # Túnel HTTP CONNECT simples
          $proxyUri = "http://$proxyHost`:$proxyPort"
          $client = New-Object System.Net.Sockets.TcpClient($proxyHost,$proxyPort)
          $stream = $client.GetStream()
          $connectRequest = "CONNECT $destIp`:$destPort HTTP/1.1`r`nHost: $destIp`r`n`r`n"
          $bytes = [System.Text.Encoding]::ASCII.GetBytes($connectRequest)
          $stream.Write($bytes,0,$bytes.Length)
          # Descartar resposta do proxy
          $buffer = New-Object byte[] 1024
          $null = $stream.Read($buffer,0,$buffer.Length)
          Write-Host "[+] Túnel de proxy estabelecido"
          return $stream
      } else {
          $client = New-Object System.Net.Sockets.TcpClient($destIp,$destPort)
          Write-Host "[+] Conexão TCP direta estabelecida"
          return $client.GetStream()
      }
  }
  
  # 4. Abrir a conexão
  $stream = Invoke-C2Connection -destIp $c2Ip -destPort $c2Port -viaProxy:$useProxy
  
  # 5. Enviar um beacon simples
  $beacon = "Beacon do CastleRAT $(Get-Date -Format o)`n"
  $bytes = [System.Text.Encoding]::UTF8.GetBytes($beacon)
  $stream.Write($bytes,0,$bytes.Length)
  Write-Host "[+] Beacon enviado"
  
  # 6. Manter o canal aberto por um curto período (simular persistência)
  Start-Sleep -Seconds 15
  
  # 7. Limpeza
  $stream.Close()
  Write-Host "[+] Conexão encerrada"

• Comandos de Limpeza:

  # Assegure que quaisquer conexões TCP remanescentes sejam encerradas
  Get-NetTCPConnection -RemotePort 9999 -State Established | ForEach-Object {
      try {
          $proc = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
          if ($proc) { Stop-Process -Id $proc.Id -Force }
      } catch {}
  }
  
  # Remover qualquer escuta proxy temporária se foi iniciada localmente
  Stop-Process -Name "python" -Force -ErrorAction SilentlyContinue

Observações Adicionais e Recomendações de Endurecimento

1. Enriquecer Detecção Baseada em Porta: Combine a verificação de porta com IPs/domínios C2 conhecidos maliciosos, impressão digital TLS, ou heurísticas de volume de tráfego anormais.
2. Permitir Lista de Serviços Legítimos: Crie uma lista de exceções para aplicativos que legitimamente usam as portas 9999 ou 8888 (por exemplo, certas ferramentas de banco de dados ou de gerenciamento).
3. Linhas de Base Comportamentais: Implante modelos estatísticos para sinalizar conexões de saída de baixa frequência para portas de alto risco originadas de pontos finais não-servidores.
4. Contexto de Processo: Correlacione eventos de firewall com o processo originador (ImageFileName, CommandLine). Sinalize conexões feitas por processos inesperados (por exemplo, powershell.exe, cmd.exe).

Aplicando essas mitigações, a resiliência da regra pode ser elevada do atual 2 para um intervalo de 4-5 , reduzindo drasticamente os falsos positivos enquanto preserva a detecção do tráfego C2 genuíno do CastleRAT.