Dentro Vidar 2026: Dall’Infezione all’Esecuzione in Memoria

Riassunto

Il rapporto esamina come Vidar si sia evoluto in un framework di attacco senza file, multi-stadio, che combina loader basati su Go, VBS, PowerShell e binari living-off-the-land per recuperare contenuti malevoli nascosti all’interno di file JPEG e TXT ospitati su un indirizzo IP remoto. I payload incorporati vengono estratti, decodificati ed eseguiti direttamente in memoria tramite RegAsm.exe, evitando il rilevamento basato su disco. L’accesso iniziale viene consegnato tramite esche di ingegneria sociale come falsi repository GitHub, siti WordPress compromessi e falsi pagine CAPTCHA. La campagna si affida anche a domini front-end di Telegram e Cloudflare per il comando e controllo e l’esfiltrazione dei dati.

Indagine

I ricercatori di Point Wild hanno tracciato l’intera catena di infezione dal primo dropper compilato in Go al payload finale di Vidar, documentando ogni livello di offuscamento lungo il percorso. La loro analisi ha evidenziato l’uso di marcatori Base64 personalizzati, stringhe invertite e caricamento riflessivo di assembly .NET per nascondere l’esecuzione. I ricercatori hanno anche descritto come WScript, PowerShell e RegAsm.exe sono stati abusati come proxy di esecuzione, consentendo al malware di decodificare e lanciare una DLL nascosta interamente in memoria. Il traffico di rete ha confermato ulteriormente il recupero basato su HTTP di payload JPEG e TXT preparati da un indirizzo IP hard-coded.

Mitigazione

I difensori dovrebbero concentrarsi sulla rilevazione delle prime fasi VBS e PowerShell della catena di infezione, incluso l’uso sospetto di RegAsm.exe, il recupero dei file JPEG o TXT dall’IP malevolo e modelli riconoscibili di marcatori Base64. Bloccare domini e indirizzi IP noti come malevoli, monitorare il traffico uscente verso Telegram e applicare controlli di esecuzione alle utilità LOLBin comuni può aiutare a ridurre l’esposizione. Si raccomanda fortemente anche il rilevamento basato sul comportamento ottimizzato per l’esecuzione senza file e le tecniche di caricamento in memoria.

Risposta

Se vengono identificati indicatori collegati alla catena di infezione Vidar, isolare immediatamente l’host interessato, terminare i processi sospetti come WScript, PowerShell e RegAsm.exe, e raccogliere immagini di memoria per la revisione forense. L’indirizzo IP identificato e i domini correlati dovrebbero essere bloccati, e qualunque scorciatoia di avvio o attività pianificata utilizzata per la persistenza dovrebbe essere rimossa. I team di sicurezza dovrebbero anche condurre una revisione completa delle credenziali focalizzandosi sui dati esposti del browser, estensioni e wallet di criptovaluta.

Esecuzione di Simulazione

Prerequisito: Il Check Pre-Flight del Telemetry & Baseline deve aver superato.

Razionale: Questa sezione dettaglia l’esecuzione precisa della tecnica dell’avversario (TTP) progettata per innescare la regola di rilevamento. I comandi e la narrazione DEVONO riflettere direttamente i TTP individuati e mirare a generare la telemetria esatta attesa dalla logica di rilevamento.

• Narrativa di Attacco & Comandi:

  1. Dropper Iniziale (WScript): L’attaccante consegna un file JScript malevolo (payload.js) che viene lanciato tramite WScript.exe. Lo script scarica un payload PowerShell codificato in base64 da un server C2 e lo scrive in %TEMP%.
  2. Fase PowerShell: Il payload scaricato viene eseguito con -ExecutionPolicy Bypass -NoProfile -WindowStyle Hidden, esegue il caricamento riflettente della DLL (T1620) di un assembly .NET malevolo (evil.dll) in memoria e rilascia l’assembly su disco.
  3. Proxy RegAsm: Per evadere il rilevamento nativo di PowerShell, l’attaccante invoca RegAsm.exe puntando a evil.dll con l’opzione /codebase , causando l’esecuzione del punto d’ingresso malevolo (T1574.014).

  La catena genera tre distinti eventi Sysmon—ognuno dei quali corrisponde al selettore della regola Image|endswith —iniziando così l’allerta.

• Script di Test di Regressione: Lo script sotto riproduce la catena sopra in un modo sicuro, in ambiente sandbox usando comandi echo innocui e una DLL fittizia (un semplice file di testo) per evitare attività realmente malevola generando ugualmente gli stessi eventi di creazione di processo.

  <# 
  Simulazione di esecuzione multi-stadio in stile Vidar 
  - Fase 1: WScript lancia un JScript che scrive uno script PowerShell in %TEMP% 
  - Fase 2: PowerShell esegue lo script, crea una DLL fittizia e lancia RegAsm 
  #>
  
  # ---------- Fase 1: WScript ----------
  $jsPath = "$env:TEMPstage1.js"
  $psPayloadPath = "$env:TEMPstage2.ps1"
  $dummyDllPath = "$env:TEMPevil.dll"
  
  # JScript che scrive su disco un semplice payload PowerShell
  $jsContent = @"
  var fso = new ActiveXObject("Scripting.FileSystemObject");
  var ts = fso.OpenTextFile("$psPayloadPath", 2, true);
  ts.WriteLine('Write-Host "[Stage 2] PowerShell eseguito"');
  ts.WriteLine('Set-Content -Path "$dummyDllPath" -Value "This is a dummy DLL"');
  ts.WriteLine('Start-Process -FilePath "$env:SystemRootMicrosoft.NETFramework64v4.0.30319RegAsm.exe" -ArgumentList "`"$dummyDllPath`" /codebase" -NoNewWindow');
  ts.Close();
  "@
  
  Set-Content -Path $jsPath -Value $jsContent -Encoding ASCII
  
  # Esegui lo JScript tramite WScript
  Write-Host "`n[Fase 1] Lanciando WScript..."
  & "$env:SystemRootSystem32WScript.exe" $jsPath
  
  # ---------- Fase 2: PowerShell ----------
  Write-Host "`n[Fase 2] Esecuzione del payload PowerShell generato..."
  & powershell.exe -NoProfile -ExecutionPolicy Bypass -File $psPayloadPath
  
  # ---------- Pulizia ----------
  Write-Host "`nPulizia dei file temporanei..."
  Remove-Item -Path $jsPath, $psPayloadPath, $dummyDllPath -Force -ErrorAction SilentlyContinue

• Comandi di Pulizia: In aggiunta alla pulizia alla fine dello script, eseguire quanto segue per garantire che nessun processo o file residuo rimanga.

  # Termina forzatamente eventuali istanze di RegAsm o PowerShell lasciate attive dal test
  Get-Process -Name regasm, powershell -ErrorAction SilentlyContinue | Stop-Process -Force
  
  # Rimuovi eventuali file residui in %TEMP% che corrispondono al pattern del test
  Get-ChildItem -Path $env:TEMP -Filter "stage*.*" -File | Remove-Item -Force