Análisis de Phantom Stealer: Dentro de una cadena de ataque de dos capas

Resumen

Phantom Stealer es un infostealer de Windows de dos etapas que comienza con un malicioso pdh.dll cargador y termina con una carga útil .NET inyectada en jsc.exe. El cargador utiliza secuestro de DLL, vaciamiento de procesos y compilación AOT nativa para reducir la probabilidad de detección. Una vez activo, la carga útil de segunda etapa roba credenciales, datos del navegador, información de billeteras de criptomonedas, contenido del portapapeles y otros datos sensibles, y también puede reemplazar direcciones de billeteras copiadas con valores controlados por el atacante. El malware se comercializa como una oferta de crimeware comercial y está siendo utilizado en ataques activos.

Investigación

Los investigadores encontraron que el cargador se copia a sí mismo a %APPDATA%MicrosoftRasManagementMpDlpService.exe y crea una clave de ejecución para mantener la persistencia. Luego descifra una carga útil cifrada doblemente con RC4, la inyecta en un jsc.exe proceso suspendido, y realiza múltiples verificaciones anti-análisis antes de comenzar el robo de datos. El stealer interno .NET es capaz de eludir el cifrado ligado a la aplicación de Chrome 127+ y exfiltrar la información robada mediante SMTP utilizando un dominio falsificado. Hilos separados manejan funciones de corte de cripto y de keylogging.

Mitigación

Los defensores deben monitorear cargas inesperadas desde rutas que no sean del sistema y aplicar controles que reduzcan el riesgo de secuestro de DLL. Los equipos de seguridad también deben detectar ejecutables desconocidos colocados en pdh.dll loads from non-system paths and enforce controls that reduce DLL hijacking risk. Security teams should also detect unfamiliar executables placed in %APPDATA%MicrosoftRasManagement y observar por la clave de ejecución RasManSvc. Las detecciones basadas en comportamiento deben enfocarse en el vaciado de procesos que involucran Run key. Behavior-based detections should focus on process hollowing involving jsc.exe, mientras el monitoreo de red debe marcar conexiones sospechosas a los dominios de comando y control identificados. El endurecimiento adicional del almacenamiento de credenciales del navegador y controles más estrictos sobre el acceso al portapapeles para aplicaciones no confiables pueden reducir aún más la exposición.

Respuesta

Alerta sobre la creación de MpDlpService.exe dentro del directorio RasManagement y sobre cambios a la clave de registro de ejecución relacionada. Investigue cualquier jsc.exe proceso que muestre signos de código inyectado y termine la actividad maliciosa de inmediato. Recopile los indicadores relevantes de compromiso, ponga en cuarentena los archivos asociados y realice un análisis forense para determinar qué credenciales y datos de billeteras pueden haber sido expuestos. Restablezca las cuentas afectadas y notifique a los usuarios afectados según sea necesario.

Ejecución de Simulación

Prerequisito: La Verificación Pre-vuelo de Telemetría y Línea Base debe haber pasado.

Razonamiento: 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 reflejan directamente los TTPs identificados y apuntan a generar la telemetría exacta esperada por la lógica de detección.

• Narrativa del Ataque y Comandos:
  Un adversario primero roba una carga útil maliciosa (por ejemplo, una DLL de shell inversa) y la almacena en el directorio del usuario. Usando como anfitrión de vaciamiento, el atacante crea un nuevo proceso, inyecta la carga útil, y reanuda la ejecución, cumpliendo con jsc.exe as a hollowing host, the attacker creates a new process, injects the payload, and resumes execution—fulfilling T1055.012 and T1055.003.
  Para asegurar persistencia, el atacante copia la DLL maliciosa a %APPDATA%MicrosoftRasManagementMpDlpService.exe y la registra como un servicio que se ejecuta al iniciar sesión, abusando del nombre del servicio legítimo (T1620).

• Script de Test de Regresión:

  # ---------------------------------------------------------
  # Script de adversario simulado – Vaciamiento de Procesos + Persistencia
  # ---------------------------------------------------------
  
  # Variables
  $appData = "$env:APPDATAMicrosoftRasManagement"
  $loaderPath = Join-Path $appData "MpDlpService.exe"
  $maliciousDll = "$env:TMPmalicious.dll"   # marcador de posición para la carga útil
  
  # 1. Prepara el directorio de persistencia
  New-Item -Path $appData -ItemType Directory -Force | Out-Null
  
  # 2. Dejar caer una DLL maliciosa ficticia (carga útil simulada)
  #    En un ataque real, esto sería una carga útil compilada; aquí creamos un archivo de cero bytes.
  New-Item -Path $maliciousDll -ItemType File -Force | Out-Null
  
  # 3. Copiar la DLL a la ubicación del servicio falsificado
  Copy-Item -Path $maliciousDll -Destination $loaderPath -Force
  
  # 4. Registrar un servicio temporal apuntando al archivo copiado (requiere administrador)
  $svcName = "MpDlpService"
  sc.exe create $svcName binPath= "`"$loaderPath`"" DisplayName= "Microsoft Ras Management Service" start= auto | Out-Null
  
  # 5. Iniciar el servicio (dispara la ejecución de MpDlpService.exe)
  sc.exe start $svcName | Out-Null
  
  # 6. Realizar vaciamiento de procesos usando jsc.exe como el anfitrión
  #    Lanzaremos jsc.exe suspendido, reemplazaremos su memoria con la carga útil ficticia,
  #    luego reanudaremos. Esto usa la función Invoke-ProcessHollowing de PowerSploit.
  function Invoke-ProcessHollowing {
      param(
          [string]$HostPath,
          [string]$PayloadPath
      )
      # Cargar API de .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;
    }
  "@
      # Crear proceso suspendido
      $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 "Failed to create suspended process" ; return }
  
      # (Pasos de inyección de carga útil omitidos – marcador de posición para técnica real)
      # Reanudar hilo
      $RESUME_THREAD = 0x00000001
      [System.Runtime.InteropServices.Marshal]::WriteInt32($pi.hThread, 0, $RESUME_THREAD) | Out-Null
  }
  
  # Ejecutar vaciamiento (usando el verdadero jsc.exe como anfitrión)
  $jscPath = "$env:SystemRootSystem32jsc.exe"
  Invoke-ProcessHollowing -HostPath $jscPath -PayloadPath $maliciousDll
  
  # ---------------------------------------------------------
  # Fin de la simulación
  # ---------------------------------------------------------

• Comandos de Limpieza:

  # Detener y eliminar servicio temporal
  sc.exe stop MpDlpService | Out-Null
  sc.exe delete MpDlpService | Out-Null
  
  # Eliminar cargador y carga útil ficticia
  Remove-Item -Path "$env:APPDATAMicrosoftRasManagementMpDlpService.exe" -Force -ErrorAction SilentlyContinue
  Remove-Item -Path "$env:TMPmalicious.dll" -Force -ErrorAction SilentlyContinue
  
  # Opcional: matar cualquier proceso jsc.exe remanente iniciado por la prueba
  Get-Process -Name jsc -ErrorAction SilentlyContinue | Stop-Process -Force