Análise do Phantom Stealer: Dentro de uma Cadeia de Ataque em Duas Camadas

Resumo

O Phantom Stealer é um infostealer para Windows em duas fases que começa com um pdh.dll carregador malicioso e termina com um payload .NET injetado em jsc.exe. O carregador utiliza DLL hijacking, process hollowing e compilação AOT nativa para reduzir a chance de detecção. Uma vez ativo, o payload de segunda fase rouba credenciais, dados de navegador, informações de carteiras de criptomoeda, conteúdo da área de transferência e outros dados sensíveis, podendo também substituir endereços de carteiras copiados por valores controlados pelo atacante. O malware é comercializado como uma oferta de crimeware e atualmente está sendo usado em ataques ativos.

Investigação

Pesquisadores descobriram que o carregador copia-se para %APPDATA%MicrosoftRasManagementMpDlpService.exe e cria uma chave Run para manter a persistência. Ele então descriptografa um payload duplamente criptografado com RC4, injeta-o em um jsc.exe processo suspenso e realiza várias verificações anti-análise antes de iniciar o roubo de dados. O infostealer interno em .NET é capaz de contornar a criptografia vinculada ao aplicativo do Chrome 127+ e exfiltra informações roubadas via SMTP usando um domínio falso. Threads separados lidam com funções de recorte de criptomoedas e keylogging.

Mitigação

Os defensores devem monitorar carregamentos inesperados pdh.dll de caminhos que não são do sistema e aplicar controles que reduzam o risco de DLL hijacking. As equipes de segurança também devem detectar executáveis desconhecidos colocados em %APPDATA%MicrosoftRasManagement e observar a chave Run RasManSvc . As detecções com base no comportamento devem focar no process hollowing envolvendo jsc.exe, enquanto o monitoramento de rede deve sinalizar conexões suspeitas com os domínios de comando e controle identificados. O fortalecimento adicional do armazenamento de credenciais do navegador e controles mais rígidos sobre o acesso à área de transferência para aplicativos não confiáveis podem reduzir ainda mais a exposição.

Resposta

Alerta sobre a criação de MpDlpService.exe dentro do diretório RasManagement e em alterações na chave de registro Run relacionada. Investigue qualquer jsc.exe processo que apresente sinais de código injetado e interrompa imediatamente a atividade maliciosa. Colete os indicadores de comprometimento relevantes, quarentena os arquivos associados e realize uma análise forense para determinar quais credenciais e dados de carteiras podem ter sido expostos. Redefina contas impactadas e notifique os usuários afetados conforme necessário.

Execução de Simulação

Pré-requisito: O Check de Pré-voo de Telemetria e Padrão deve ter passado.

Justificativa: Esta seção detalha a execução precisa da técnica de adversário (TTP) projetada para acionar a regra de detecção. Os comandos e narrativa refletem diretamente as TTPs identificadas e visam gerar a telemetria exata esperada pela lógica de detecção.

• Narrativa de Ataque & Comandos:
  Um adversário primeiro rouba um payload malicioso (por exemplo, uma DLL de shell reverso) e o armazena no diretório do usuário usando Como um host de hollowing, o atacante cria um novo processo, injeta o payload e retoma a execução, cumprindo jsc.exe T1055.012 T1055.012 and T1055.003.
  Para garantir persistência, o atacante copia a DLL maliciosa para %APPDATA%MicrosoftRasManagementMpDlpService.exe e registra como um serviço que é executado no logon, abusando do nome legítimo do serviço (T1620).

• Script de Teste de Regressão:

  # ---------------------------------------------------------
  # Script simulado de adversário – Process Hollowing + Persistência
  # ---------------------------------------------------------
  
  # Variáveis
  $appData = "$env:APPDATAMicrosoftRasManagement"
  $loaderPath = Join-Path $appData "MpDlpService.exe"
  $maliciousDll = "$env:TMPmalicious.dll"   # espaço reservado para payload
  
  # 1. Prepare o diretório de persistência
  New-Item -Path $appData -ItemType Directory -Force | Out-Null
  
  # 2. Soltar uma DLL maliciosa dummy (payload simulado)
  #    Em um ataque real, isso seria um payload compilado; aqui criamos um arquivo de zero bytes.
  New-Item -Path $maliciousDll -ItemType File -Force | Out-Null
  
  # 3. Copiar a DLL para o local do serviço disfarçado
  Copy-Item -Path $maliciousDll -Destination $loaderPath -Force
  
  # 4. Registrar um serviço temporário apontando para o arquivo copiado (requer admin)
  $svcName = "MpDlpService"
  sc.exe create $svcName binPath= "`"$loaderPath`"" DisplayName= "Microsoft Ras Management Service" start= auto | Out-Null
  
  # 5. Iniciar o serviço (aciona execução de MpDlpService.exe)
  sc.exe start $svcName | Out-Null
  
  # 6. Realizar process hollowing usando jsc.exe como hospedeiro
  #    Vamos iniciar jsc.exe suspenso, substituir sua memória pelo payload dummy,
  #    então retomar. Isso usa a função Invoke-ProcessHollowing do PowerSploit.
  function Invoke-ProcessHollowing {
      param(
          [string]$HostPath,
          [string]$PayloadPath
      )
      # Carregar APIs .NET
      Add-Type @"
  using System;
  using System.Diagnostics;
  using System.Runtime.InteropServices;
  public class Hollow {
    [DllImport("kernel32.dll")] public static extern bool CreateProcess(string appName, string cmdLine,
        IntPtr procSec, IntPtr threadSec, bool inherit, uint flags,
        IntPtr env, string cwd, ref STARTUPINFO si, out PROCESS_INFORMATION pi);
    [StructLayout(LayoutKind.Sequential)] 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;
    }
  "@
      # Criar processo suspenso
      $si = New-Object Hollow+STARTUPINFO
      $pi = New-Object Hollow+PROCESS_INFORMATION
      $si.cb = [Runtime.InteropServices.Marshal]::SizeOf($si)
      $CREATE_SUSPENDED = 0x00000004
      $ok = [Hollow]::CreateProcess($null, "`"$HostPath`"", [IntPtr]::Zero, [IntPtr]::Zero, $false,
          $CREATE_SUSPENDED, [IntPtr]::Zero, $null, [ref]$si, [ref]$pi)
      if (-not $ok) { Write-Error "Falha ao criar processo suspenso" ; return }
  
      # (Etapas de injeção de payload omitidas – espaço reservado para técnica real)
      # Retomar thread
      $RESUME_THREAD = 0x00000001
      [System.Runtime.InteropServices.Marshal]::WriteInt32($pi.hThread, 0, $RESUME_THREAD) | Out-Null
  }
  
  # Executar hollowing (usando o real jsc.exe como hospedeiro)
  $jscPath = "$env:SystemRootSystem32jsc.exe"
  Invoke-ProcessHollowing -HostPath $jscPath -PayloadPath $maliciousDll
  
  # ---------------------------------------------------------
  # Fim da simulação
  # ---------------------------------------------------------

• Comandos de Limpeza:

  # Parar e excluir serviço temporário
  sc.exe stop MpDlpService | Out-Null
  sc.exe delete MpDlpService | Out-Null
  
  # Remover loader e payload dummy
  Remove-Item -Path "$env:APPDATAMicrosoftRasManagementMpDlpService.exe" -Force -ErrorAction SilentlyContinue
  Remove-Item -Path "$env:TMPmalicious.dll" -Force -ErrorAction SilentlyContinue
  
  # Opcional: encerrar qualquer processo jsc.exe remanescente iniciado pelo teste
  Get-Process -Name jsc -ErrorAction SilentlyContinue | Stop-Process -Force