Analisi di Phantom Stealer: All’interno di una Catena di Attacco a Due Strati

Riassunto

Phantom Stealer è un infostealer Windows a due stadi che inizia con un malicioso pdh.dll loader e termina con un payload .NET iniettato in jsc.exe. Il loader utilizza DLL hijacking, process hollowing e compilazione nativa AOT per ridurre la possibilità di rilevamento. Una volta attivo, il payload del secondo stadio ruba credenziali, dati del browser, informazioni sui portafogli di criptovalute, contenuti degli appunti e altri dati sensibili, e può anche sostituire indirizzi di portafogli copiati con valori controllati dall’attaccante. Il malware è commercializzato come offerta di crimeware ed è attualmente utilizzato in attacchi attivi.

Indagine

I ricercatori hanno trovato che il loader copia sé stesso in %APPDATA%MicrosoftRasManagementMpDlpService.exe e crea una chiave Run per mantenere la persistenza. Decrittografa quindi un payload criptato doppio RC4 e lo inietta in un jsc.exe processo sospeso, esegue numerosi controlli anti-analisi prima di avviare il furto di dati. L’intern .NET stealer è in grado di bypassare la crittografia legata all’app di Chrome 127+ ed esfiltra informazioni rubate tramite SMTP usando un dominio spoofato. Thread separati gestiscono funzionalità di crypto clipping e keylogging.

Mitigazione

I difensori dovrebbero monitorare caricamenti inaspettati pdh.dll da percorsi non di sistema e imporre controlli che riducono il rischio di DLL hijacking. I team di sicurezza dovrebbero anche rilevare eseguibili non familiari collocati in %APPDATA%MicrosoftRasManagement e osservare la chiave Run RasManSvc Le rilevazioni basate sul comportamento dovrebbero concentrarsi sul process hollowing che coinvolge jsc.exe, mentre il monitoraggio della rete dovrebbe segnalare connessioni sospette ai domini di comando e controllo identificati. Ulteriore indurimento dell’archiviazione delle credenziali del browser e controlli più stretti sull’accesso agli appunti per le applicazioni non attendibili possono ulteriormente ridurre l’esposizione.

Risposta

Allertare alla creazione di MpDlpService.exe all’interno della directory RasManagement e alle modifiche alla chiave di registro Run correlata. Investigare qualsiasi jsc.exe processo che mostra segni di codice iniettato e terminare immediatamente l’attività maligna. Raccogliere gli indicatori di compromissione pertinenti, mettere in quarantena i file associati ed eseguire analisi forensi per determinare quali credenziali e dati del portafoglio potrebbero essere stati esposti. Reimpostare i conti colpiti e informare gli utenti interessati se necessario.

Esecuzione Simulazione

Prerequisito: Il Controllo Pre-volo di Telemetria & Baseline deve essere passato.

Razionale: Questa sezione delinea l’esecuzione precisa della tecnica avversaria (TTP) progettata per innescare la regola di rilevamento. I comandi e la narrativa riflettono direttamente le TTP identificate e mirano a generare l’esatta telemetria prevista dalla logica di rilevamento.

• Narrativa & Comandi di Attacco:
  Un avversario innanzitutto ruba un payload malevolo (ad esempio, una DLL di shell inversa) e lo memorizza nella directory %APPDATA% dell'utente. Usando come host per il hollowing, l’attaccante crea un nuovo processo, inietta il payload e riprende l’esecuzione— adempiendo a jsc.exe , T1055.003 , T1055.003 and Per garantire la persistenza, l’attaccante copia la DLL malevola in.
  To ensure persistence, the attacker copies the malicious DLL to %APPDATA%MicrosoftRasManagementMpDlpService.exe e la registra come un servizio che si esegue all’accesso, abusando del nome del servizio legittimo (T1620).

• Script di Test di Regressione:

  # ---------------------------------------------------------
  # Script avversario simulato – Process Hollowing + Persistenza
  # ---------------------------------------------------------
  
  # Variabili
  $appData = "$env:APPDATAMicrosoftRasManagement"
  $loaderPath = Join-Path $appData "MpDlpService.exe"
  $maliciousDll = "$env:TMPmalicious.dll"   # placeholder per il payload
  
  # 1. Preparare la directory di persistenza
  New-Item -Path $appData -ItemType Directory -Force | Out-Null
  
  # 2. Lascia cadere una DLL malevola fittizia (payload simulato)
  #    In un attacco reale questo sarebbe un payload compilato; qui creiamo un file da zero byte.
  New-Item -Path $maliciousDll -ItemType File -Force | Out-Null
  
  # 3. Copia la DLL nella posizione di servizio spoofato
  Copy-Item -Path $maliciousDll -Destination $loaderPath -Force
  
  # 4. Registra un servizio temporaneo che punta al file copiato (richiede admin)
  $svcName = "MpDlpService"
  sc.exe create $svcName binPath= "`"$loaderPath`"" DisplayName= "Microsoft Ras Management Service" start= auto | Out-Null
  
  # 5. Avvia il servizio (innesca l'esecuzione di MpDlpService.exe)
  sc.exe start $svcName | Out-Null
  
  # 6. Esegui il process hollowing usando jsc.exe come host
  #    Lanceremo jsc.exe sospeso, sostituiremo la sua memoria con il payload fittizio,
  #    quindi riprenderemo. Questo usa la funzione Invoke-ProcessHollowing da PowerSploit.
  function Invoke-ProcessHollowing {
      param(
          [string]$HostPath,
          [string]$PayloadPath
      )
      # Carica API .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;
    }
  "@
      # Crea processo sospeso
      $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 "Creatione processo sospeso non riuscita" ; return }
  
      # (Passaggi iniezione payload omessi – placeholder per tecnica reale)
      # Riprendere thread
      $RESUME_THREAD = 0x00000001
      [System.Runtime.InteropServices.Marshal]::WriteInt32($pi.hThread, 0, $RESUME_THREAD) | Out-Null
  }
  
  # Esegui hollowing (usando il vero jsc.exe come host)
  $jscPath = "$env:SystemRootSystem32jsc.exe"
  Invoke-ProcessHollowing -HostPath $jscPath -PayloadPath $maliciousDll
  
  # ---------------------------------------------------------
  # Fine della simulazione
  # ---------------------------------------------------------

• Comandi di Pulizia:

  # Arresta e cancella servizio temporaneo
  sc.exe stop MpDlpService | Out-Null
  sc.exe delete MpDlpService | Out-Null
  
  # Rimuovi loader e payload fittizio
  Remove-Item -Path "$env:APPDATAMicrosoftRasManagementMpDlpService.exe" -Force -ErrorAction SilentlyContinue
  Remove-Item -Path "$env:TMPmalicious.dll" -Force -ErrorAction SilentlyContinue
  
  # Opzionale: elimina processi jsc.exe residui avviati dal test
  Get-Process -Name jsc -ErrorAction SilentlyContinue | Stop-Process -Force