PureLogs Livré par Stéganographie PawsRunner

Résumé

La campagne repose sur un e-mail de phishing contenant une archive TXZ qui livre un chargeur JavaScript, lequel définit des variables d’environnement et lance conhost.exe en mode sans tête. Le chargeur décrypte ensuite un assembly .NET connu sous le nom de PawsRunner, qui récupère des images PNG contenant un contenu crypté caché grâce à des techniques stéganographiques. À partir de ces images, le malware extrait la charge utile finale : le voleur d’informations PureLogs .NET. Une fois actif, PureLogs se connecte à un serveur de commande et de contrôle à distance via HTTPS et exfiltre les identifiants de navigateur ainsi que les informations système.

Enquête

L’analyse a montré que le chargeur JavaScript extrait des commandes des variables d’environnement du processus, lance PowerShell avec un indicateur de fenêtre cachée et décrypte une charge utile chiffrée en AES qui est exécutée via la réflexion .NET. PawsRunner fait tourner trois API réseau et trois chaînes d’agent utilisateur différentes tout en téléchargeant des fichiers PNG, puis analyse iTXt and IEND pour localiser les données dissimulées et décrypte l’étape suivante avec RC4. PureLogs utilise à son tour TripleDES et Gzip pour charger une DLL téléchargeur, effectue des requêtes HTTP protégées par TLS vers des points de terminaison spécifiques, et collecte un large ensemble de données liées au navigateur depuis le système de la victime.

Atténuation

Les organisations devraient bloquer les pièces jointes TXZ à la passerelle e-mail, surveiller les conhost.exe instances s’exécutant sans fenêtre visible, et détecter PowerShell lancé avec le -w hidden drapeau. Les équipes de sécurité devraient également déployer des signatures pour PawsRunner et PureLogs, restreindre le trafic sortant vers le domaine et l’adresse IP de commande et de contrôle identifiés, et limiter l’exécution des assemblies .NET non signés. Dans la mesure du possible, une détection de la stéganographie devrait être appliquée aux fichiers image entrants suspects.

Réponse

Si cette activité est détectée, isolez le point de terminaison affecté, terminez les processus suspects conhost.exe et PowerShell, et supprimez toute binaire .NET déposée du système. Les identifiants compromis doivent être révoqués, l’authentification multifactorielle appliquée, et les mots de passe de navigateur stockés réinitialisés. Les enquêteurs devraient également effectuer une analyse des réseaux pour confirmer qu’aucune communication supplémentaire de commande et de contrôle n’a eu lieu et appliquer les étapes de remédiation pour éviter la réinfection.

Exécution de simulation

Prérequis: Le test préliminaire de télémétrie et de référence doit avoir réussi.

• Narratif et commandes de l’attaque

  1. Étape 1 – Préparer la charge utile chiffrée
     • L’attaquant crée une petite charge utile factice ("secret"), la chiffre avec AES-256 en utilisant une clé connue, encode la chaîne chiffrée en Base64 et la stocke dans une variable d’environnement ENC_PAYLOAD.
  2. Étape 2 – Exécuter le chargeur de décryptage PowerShell
     • Une seule ligne lit ENC_PAYLOAD, décode la chaîne Base64, construit un AesCryptoServiceProvider, dérive la clé/IV, décrypte les données et exécute éventuellement le texte en clair.
  3. Étape 3 – Générer la télémétrie de détection
     • La commande PowerShell inclut le mot littéral « AES » (par exemple, New-Object System.Security.Cryptography.AesCryptoServiceProvider) et est enregistrée en tant qu’EventID 4104, satisfaisant la règle de détection.

• Script de test de régression

  # -------------------------------------------------
  # Simulation de décryptage AES PowerShell (Déclenche la détection)
  # -------------------------------------------------
  # 1. Définir une clé et un IV statiques de 256 bits (à des fins de démo)
  $key = [byte[]](0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,
                     0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20)
  $iv  = [byte[]](0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0)
  
  # 2. Charge utile en texte clair (exemple)
  $plain = [System.Text.Encoding]::UTF8.GetBytes("secret data")
  
  # 3. Chiffrer la charge utile en utilisant AES (CBC, PKCS7)
  $aes = [System.Security.Cryptography.AesCryptoServiceProvider]::new()
  $aes.Key = $key
  $aes.IV  = $iv
  $aes.Mode = [System.Security.Cryptography.CipherMode]::CBC
  $aes.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7
  $encryptor = $aes.CreateEncryptor()
  $cipherBytes = $encryptor.TransformFinalBlock($plain,0,$plain.Length)
  $cipherB64 = [Convert]::ToBase64String($cipherBytes)
  
  # 4. Stocker le texte chiffré dans une variable d'environnement
  
  # 5. Chargeur de décryptage – la ligne exacte qui sera enregistrée (contient "AES")
  $loader = @"
  `$enc = [System.Environment]::GetEnvironmentVariable('ENC_PAYLOAD')
  `$bytes = [Convert]::FromBase64String(`$enc)
  `$aes = New-Object System.Security.Cryptography.AesCryptoServiceProvider
  `$aes.Key = $($key -join ',')
  `$aes.IV  = $($iv -join ',')
  `$decryptor = `$aes.CreateDecryptor()
  `$plain = `$decryptor.TransformFinalBlock(`$bytes,0,`$bytes.Length)
  `$result = [System.Text.Encoding]::UTF8.GetString(`$plain)
  Write-Output `"Decrypted: `$result`"
  "@
  
  # Exécuter le chargeur (sera capturé comme EventID 4104)
  Invoke-Expression $loader

• Commandes de nettoyage

  # Supprimer la variable d'environnement
  
  # Effacer toutes les variables temporaires de la session
  Remove-Variable -Name key,iv,plain,cipherBytes,cipherB64,loader -ErrorAction SilentlyContinue

Validation post-simulation

1. Exécutez la requête de validation (exemple KQL ci-dessus) mais filtrez pour ScriptBlockText contient "AES" pour confirmer que la détection a été déclenchée.
2. Examinez les détails de l’alerte dans le SIEM ; vérifiez que le nom de l’alerte correspond à la règle (si définie) et que la gravité est signalée comme Haute.

Remarques finales

• La règle détecte avec succès le scénario d’utilisation simple de « AES ».
• Les adversaires peuvent échapper en divisant le mot (par exemple, "AE"+"S"), en chargeant la classe .NET via la réflexion, ou en effectuant le décryptage dans des binaires compilés.
• Améliorer la règle avec des indicateurs comportementaux (utilisation de variables d’environnement pour le texte chiffré, chaînes à haute entropie, création d’ AesCryptoServiceProvider objets, et appels TransformFinalBlock ) améliorera la résilience face à une obfuscation simple.