Phantom Stealer Analyse: Einblick in eine zweistufige Angriffskette

Zusammenfassung

Phantom Stealer ist ein zweistufiges Windows-Infostealer, das mit einem bösartigen pdh.dll Loader beginnt und mit einer .NET-Nutzlast endet, die in jsc.exeinjektiert wird. Der Loader verwendet DLL-Hijacking, Process Hollowing und native AOT-Kompilierung, um die Erkennungschancen zu verringern. Sobald er aktiv ist, stiehlt die Nutzlast der zweiten Stufe Anmeldedaten, Browserdaten, Kryptowährungs-Wallet-Informationen, Zwischenablage-Inhalte und andere sensible Daten und kann auch kopierte Wallet-Adressen durch von Angreifern kontrollierte Werte ersetzen. Die Malware wird als kommerzielles Crimeware-Angebot vermarktet und derzeit in aktiven Angriffen eingesetzt.

Untersuchung

Forscher fanden heraus, dass der Loader sich selbst zu %APPDATA%MicrosoftRasManagementMpDlpService.exe kopiert und einen Run-Schlüssel erstellt, um die Persistenz zu gewährleisten. Dann entschlüsselt er eine doppelt RC4-verschlüsselte Nutzlast, injiziert sie in einen angehaltenen jsc.exe Prozess und führt mehrere Anti-Analysetechniken durch, bevor der Datendiebstahl beginnt. Der innere .NET-Stealer kann die Chrome-127+-App-gebundene Verschlüsselung umgehen und exfiltriert gestohlene Informationen über SMTP unter Verwendung einer gefälschten Domain. Separate Threads verwalten das Kryptoclipping und die Keylogging-Funktionen.

Abwehrmaßnahmen

Verteidiger sollten unerwartete pdh.dll Ladevorgänge von nicht-systemeigenen Pfaden überwachen und Kontrollen durchsetzen, die das Risiko des DLL-Hijackings reduzieren. Sicherheitsteams sollten auch unbekannte ausführbare Dateien, die in %APPDATA%MicrosoftRasManagement abgelegt wurden, erkennen und den RasManSvc Run-Schlüssel überwachen. Verhaltensbasierte Erkennungen sollten sich auf Process Hollowing, das jsc.exebetrifft, konzentrieren, während die Netzwerküberwachung verdächtige Verbindungen zu den identifizierten Command-and-Control-Domains kennzeichnen sollte. Eine zusätzliche Härtung der Browser-Anmeldeinformationsspeicherung und strengere Kontrollen des Zwischenablagezugriffs für nicht vertrauenswürdige Anwendungen können die Gefährdung weiter reduzieren.

Reaktion

Alarmieren Sie bei der Erstellung von MpDlpService.exe im RasManagement-Verzeichnis und bei Änderungen am zugehörigen Run-Registry-Schlüssel. Untersuchen Sie jeden jsc.exe Prozess, der Anzeichen von injiziertem Code zeigt, und beenden Sie die böswilligen Aktivitäten sofort. Sammeln Sie die relevanten Indikatoren für kompromittierte Systeme, isolieren Sie die zugehörigen Dateien und führen Sie eine forensische Analyse durch, um festzustellen, welche Anmeldedaten und Wallet-Daten möglicherweise offengelegt wurden. Setzen Sie betroffene Konten zurück und benachrichtigen Sie betroffene Benutzer nach Bedarf.

Simulation Execution

Voraussetzung: Der Telemetrie- & Baseline-Pre-flight-Check muss bestanden sein.

Begründung: In diesem Abschnitt werden die präzise Ausführung der adversarialen Technik (TTP) beschrieben, die darauf abzielt, die Erkennungsregel auszulösen. Die Befehle und Erzählungen spiegeln direkt die identifizierten TTPs wider und sollen die genaue Telemetrie erzeugen, die von der Erkennungslogik erwartet wird.

• Angriffserzählung und Befehle:
  Ein Angreifer stiehlt zuerst eine bösartige Nutzlast (z. B. eine Reverse-Shell-DLL) und speichert sie im Verzeichnis des Benutzers %APPDATA% ab. Mit jsc.exe als Hollowing-Host erstellt der Angreifer einen neuen Prozess, injiziert die Nutzlast und setzt die Ausführung fort – erfüllt T1055.012 and T1055.003.
  Um die Persistenz sicherzustellen, kopiert der Angreifer die bösartige DLL nach %APPDATA%MicrosoftRasManagementMpDlpService.exe und registriert sie als Dienst, der beim Anmelden ausgeführt wird und den legitimen Dienstnamen ausnutzt (T1620).

• Regressionstest-Skript:

  # ---------------------------------------------------------
  # Simuliertes Angreiferskript – Prozess-Hollowing + Persistenz
  # ---------------------------------------------------------
  
  # Variablen
  $appData = "$env:APPDATAMicrosoftRasManagement"
  $loaderPath = Join-Path $appData "MpDlpService.exe"
  $maliciousDll = "$env:TMPmalicious.dll"   # Platzhalter für Nutzlast
  
  # 1. Persistenzverzeichnis vorbereiten
  New-Item -Path $appData -ItemType Directory -Force | Out-Null
  
  # 2. Dummy-gefährliche DLL ablegen (simulierte Nutzlast)
  #    In einem echten Angriff wäre dies eine kompilierte Nutzlast; hier erstellen wir eine Null-Byte-Datei.
  New-Item -Path $maliciousDll -ItemType File -Force | Out-Null
  
  # 3. Kopieren Sie die DLL an den gefälschten Dienststandort
  Copy-Item -Path $maliciousDll -Destination $loaderPath -Force
  
  # 4. Registrieren Sie einen temporären Dienst, der auf die kopierte Datei verweist (erfordert Adminrechte)
  $svcName = "MpDlpService"
  sc.exe create $svcName binPath= "`"$loaderPath`"" DisplayName= "Microsoft Ras Management Service" start= auto | Out-Null
  
  # 5. Starten Sie den Dienst (löst die Ausführung von MpDlpService.exe aus)
  sc.exe start $svcName | Out-Null
  
  # 6. Führen Sie Process Hollowing mit jsc.exe als Host durch
  #    Wir werden jsc.exe angehalten starten, seinen Speicher mit der Dummy-Nutzlast ersetzen,
  #    dann fortsetzen. Dies verwendet die Funktion Invoke-ProcessHollowing von PowerSploit.
  function Invoke-ProcessHollowing {
      param(
          [string]$HostPath,
          [string]$PayloadPath
      )
      # .NET-APIs laden
      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;
    }
  "@
      # Prozess angehalten erstellen
      $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 "Fehler beim Erstellen des angehaltenen Prozesses" ; return }
  
      # (Payload-Injektionsschritte weggelassen – Platzhalter für echte Technik)
      # Faden fortsetzen
      $RESUME_THREAD = 0x00000001
      [System.Runtime.InteropServices.Marshal]::WriteInt32($pi.hThread, 0, $RESUME_THREAD) | Out-Null
  }
  
  # Führen Sie Hollowing aus (mit dem echten jsc.exe als Host)
  $jscPath = "$env:SystemRootSystem32jsc.exe"
  Invoke-ProcessHollowing -HostPath $jscPath -PayloadPath $maliciousDll
  
  # ---------------------------------------------------------
  # Ende der Simulation
  # ---------------------------------------------------------

• Bereinigungskommandos:

  # Temporären Dienst stoppen und löschen
  sc.exe stop MpDlpService | Out-Null
  sc.exe delete MpDlpService | Out-Null
  
  # Loader und Dummy-Nutzlast entfernen
  Remove-Item -Path "$env:APPDATAMicrosoftRasManagementMpDlpService.exe" -Force -ErrorAction SilentlyContinue
  Remove-Item -Path "$env:TMPmalicious.dll" -Force -ErrorAction SilentlyContinue
  
  # Optional: Beenden Sie eventuell zurückgebliebene jsc.exe-Prozesse, die durch den Test gestartet wurden
  Get-Process -Name jsc -ErrorAction SilentlyContinue | Stop-Process -Force