The latest ThreatsDay roundup from The Hacker News isn't a single story — it's a pattern. An update prompt. A login box. A search answer. A coding assistant. A link your users have clicked a hundred times before. Each of these is a trusted path: a workflow so routine that neither users nor controls scrutinize it. This week's reporting makes the pattern explicit:
- AI search poisoning — attackers are manipulating AI-generated search answers and summaries so that malicious links, fake support numbers, and trojanized downloads surface as authoritative results.
- AI coding tools leaking repositories — AI-assisted development environments are exfiltrating or exposing private source code, secrets, and repository contents beyond what developers intended to share.
- One-click code execution — attack chains that require nothing more than a single user click on a crafted link or prompt to achieve code execution, with no macro, no attachment, and no obvious exploit artifact.
- Fake prompts that look real enough — credential dialogs and update notifications rendered convincingly inside browsers and applications.
None of these require a memory corruption bug or a zero-day. They require something cheaper: your users' trained reflexes and your tooling's implicit trust. That is precisely why they work, and why your detection strategy has to shift from "find the exploit" to "watch what happens after the click."
Technical Analysis: How These Chains Actually Execute
Because this is a roundup rather than a single CVE disclosure, there are no vendor patch versions to chase — the defensive value is in understanding the shared mechanics. Across all of these stories, the attack chains converge on three observable behaviors.
1. Search and AI-answer poisoning → browser-spawned payloads
The victim searches for a driver, a remote-desktop tool, a PDF converter, or a "customer support number." The poisoned AI answer or promoted result delivers a malicious page or installer. The critical telemetry point: the payload execution chain begins with a browser process as the parent. Whether the lure delivers an MSIX installer, an HTA, a ClickFix-style "copy this command to fix the error" prompt, or a fake update, the second stage almost universally involves a browser spawning a scripting engine (powershell.exe, mshta.exe, wscript.exe, cmd.exe) or the user being tricked into pasting commands into Run/Terminal.
2. AI coding assistants → repository and secret exposure
The exposure vectors here are configuration-driven rather than exploit-driven: over-permissive extensions, telemetry settings that ship source context to third parties, prompt-injection against the assistant causing it to read and transmit files it shouldn't, or malicious "suggested" dependencies and config snippets. The observable artifacts: unexpected processes reading .git configuration, credential helpers, SSH keys, or .env files, and editor/IDE processes making outbound connections to domains outside your approved AI-provider allowlist. A poisoned suggestion can also manifest as the assistant modifying .git/config, package.json install scripts, or CI pipeline definitions — which is why file-integrity monitoring on repo metadata matters.
3. One-click execution → protocol handlers and living-off-the-land
One-click chains typically abuse registered URI protocol handlers, signed binary proxy execution, or application-specific deep links. The victim clicks; a legitimate, signed binary does the dirty work. Defenders should watch for script interpreters and LOLBins launched with parent processes that have no business spawning them — browsers, Office applications, chat clients, PDF readers — and for command lines containing encoded payloads, download cradles, or curl/certutil retrieval of second stages.
Exploitation status
These are not theoretical techniques. Search poisoning (SEO and AI-answer manipulation) has been delivering stealers and RATs at scale throughout 2025–2026, ClickFix-style fake-prompt social engineering is one of the most reported initial-access vectors in current IR casework, and AI-tooling data exposure has moved from research demo to active abuse. Treat all three as in-the-wild, actively used techniques.
Detection & Response
The detections below target the convergence points — the moments where every one of these varied lures collapses into the same observable execution behavior. That is where your fidelity is highest.
Sigma Rules
---
title: Browser Spawning Script Interpreter or LOLBin
title: Browser Spawning Script Interpreter or LOLBin
id: 3f8a2c71-9b4e-4d12-a756-2c8e9f0a1b34
status: experimental
description: Detects web browsers spawning script interpreters or living-off-the-land binaries, consistent with AI search poisoning, ClickFix fake-prompt, and malvertising payload chains where the lure page initiates execution.
references:
- https://thehackernews.com/2026/09/threatsday-ai-search-poisoning-ai.html
- https://attack.mitre.org/techniques/T1204/002/
- https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/09/18
tags:
- attack.execution
- attack.t1204.002
- attack.t1059
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith:
- '\chrome.exe'
- '\msedge.exe'
- '\firefox.exe'
- '\brave.exe'
- '\opera.exe'
selection_child:
Image|endswith:
- '\powershell.exe'
- '\pwsh.exe'
- '\mshta.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\cmd.exe'
- '\rundll32.exe'
- '\certutil.exe'
- '\bitsadmin.exe'
condition: selection_parent and selection_child
falsepositives:
- Rare enterprise browser extensions performing scripted automation
- Legitimate software updaters (validate against software inventory)
level: high
---
title: Suspicious Access to Git Credentials and SSH Keys by Non-Developer Tooling
id: 8c1d4e92-6a3f-4b87-c921-5d7a0e3f6b28
status: experimental
description: Detects command-line access to git credential stores, SSH private keys, or environment files by utilities commonly abused for exfiltration, consistent with AI coding tool compromise or prompt-injection driven repository and secret leakage.
references:
- https://thehackernews.com/2026/09/threatsday-ai-search-poisoning-ai.html
- https://attack.mitre.org/techniques/T1552/001/
- https://attack.mitre.org/techniques/T1567/
author: Security Arsenal
date: 2026/09/18
tags:
- attack.credential_access
- attack.t1552.001
- attack.exfiltration
- attack.t1567
logsource:
category: process_creation
product: windows
detection:
selection_paths:
CommandLine|contains:
- '\.git\config'
- 'credentials.git'
- '.git-credentials'
- '\.ssh\id_rsa'
- '\.ssh\id_ed25519'
- '\.env'
- 'git credential'
selection_tools:
Image|endswith:
- '\curl.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\certutil.exe'
- '\cmd.exe'
- '\findstr.exe'
- '\type.exe'
condition: selection_paths and selection_tools
falsepositives:
- Developer scripts managing dotfiles or CI bootstrap automation
- Legitimate git credential helper operations (tune by Image and user context)
level: high
---
title: Encoded or Download-Cradle Command Line Indicative of One-Click Execution Chain
id: 5b9e7f34-2d8c-4a15-b634-9f1c4a8e2d07
status: experimental
description: Detects encoded PowerShell, inline download cradles, or paste-into-Run style commands associated with one-click execution lures and ClickFix fake-prompt campaigns delivered via poisoned search results.
references:
- https://thehackernews.com/2026/09/threatsday-ai-search-poisoning-ai.html
- https://attack.mitre.org/techniques/T1059/001/
- https://attack.mitre.org/techniques/T1105/
author: Security Arsenal
date: 2026/09/18
tags:
- attack.execution
- attack.t1059.001
- attack.t1105
logsource:
category: process_creation
product: windows
detection:
selection_encoded:
CommandLine|contains:
- ' -enc '
- ' -ec '
- '-EncodedCommand'
- 'FromBase64String'
selection_cradle:
CommandLine|contains:
- 'Invoke-WebRequest'
- 'Invoke-RestMethod'
- 'iwr '
- 'irm '
- 'DownloadString'
- 'Start-BitsTransfer'
- 'mshta http'
selection_suspicious_pipe:
CommandLine|contains:
- '| iex'
- '|iex'
- 'IEX ('
condition: selection_encoded or (selection_cradle and selection_suspicious_pipe)
falsepositives:
- Administrative automation using encoded commands (tune per admin account and host role)
level: high
KQL — Microsoft Sentinel / Defender Hunt
This query hunts the full kill chain in one pass: browsers or Office/chat clients spawning script interpreters, plus credential-file access patterns associated with repo/secret leakage from developer workstations.
let ScriptEngines = dynamic(["powershell.exe","pwsh.exe","mshta.exe","wscript.exe","cscript.exe","cmd.exe","rundll32.exe","certutil.exe","bitsadmin.exe"]);
let LureParents = dynamic(["chrome.exe","msedge.exe","firefox.exe","brave.exe","opera.exe","winword.exe","excel.exe","outlook.exe","teams.exe","slack.exe","acrord32.exe"]);
let SecretPaths = dynamic(["\\.git\\config",".git-credentials","\\.ssh\\id_","\\.env","git credential"]);
union
(
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where FileName in~ (ScriptEngines)
| where InitiatingProcessFileName in~ (LureParents)
| extend HuntSignal = "BrowserOrOfficeSpawnedScriptEngine"
| project TimeGenerated, HuntSignal, DeviceName, AccountName, InitiatingProcessFileName, FileName, ProcessCommandLine, InitiatingProcessCommandLine, SHA256, ReportId
),
(
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where ProcessCommandLine has_any (SecretPaths)
| where FileName in~ (dynamic(["curl.exe","powershell.exe","pwsh.exe","certutil.exe","cmd.exe","findstr.exe"]))
| where InitiatingProcessFileName !in~ (dynamic(["git.exe","code.exe","devenv.exe","idea64.exe"]))
| extend HuntSignal = "NonGitProcessReadingRepoSecrets"
| project TimeGenerated, HuntSignal, DeviceName, AccountName, InitiatingProcessFileName, FileName, ProcessCommandLine, SHA256, ReportId
)
| order by TimeGenerated desc
For Linux developer workstations ingested via Syslog/CEF, pivot on Syslog where ProcessName in ("curl","wget","bash") and ProcessCommandLine contains .git/config, id_rsa, or .env with a parent that isn't the developer's known shell or IDE.
Velociraptor VQL
This artifact sweeps endpoints for the two highest-fidelity artifacts: suspicious parent-child execution chains and processes holding open handles to secret material.
-- Hunt: Trusted-Path Execution Chains and Secret File Access
-- Targets browser-spawned script engines and non-dev tooling touching repo secrets
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime,
get_field(member='Name', item=pslist(pid=Ppid)) AS ParentName
FROM pslist()
WHERE (
-- Script engines or LOLBins spawned by browsers/office/chat clients
Name =~ '(?i)(powershell|pwsh|mshta|wscript|cscript|cmd|rundll32|certutil|bitsadmin)\.exe'
AND get_field(member='Name', item=pslist(pid=Ppid)) =~ '(?i)(chrome|msedge|firefox|brave|opera|winword|excel|outlook|teams|slack)\.exe'
)
OR (
-- Command lines referencing repo secrets, SSH keys, or env files
CommandLine =~ '(?i)(\.git[/\\\\]config|\.git-credentials|id_rsa|id_ed25519|\.env|git credential)'
AND Name !~ '(?i)(git|code|devenv|idea64)\.exe'
)
ORDER BY CreateTime DESC
Remediation & Hardening Script
The following PowerShell audits a Windows developer workstation for the specific exposure surface described in this roundup: VS Code extensions not on an allowlist, suspicious entries in git configuration (injected URLs or credential helpers), recently registered custom URI protocol handlers, and whether key ASR rules that blunt browser-spawned payload chains are enabled.
# Security Arsenal - Trusted Path Attack Surface Audit
# Run elevated. Read-only audit; no system changes are made.
Write-Host "=== [1/4] VS Code Extension Audit ===" -ForegroundColor Cyan
$extPath = "$env:USERPROFILE\.vscode\extensions"
if (Test-Path $extPath) {
Get-ChildItem $extPath -Directory | ForEach-Object {
$pkg = Join-Path $_.FullName "package.json"
if (Test-Path $pkg) {
$meta = Get-Content $pkg -Raw | ConvertFrom-Json
[PSCustomObject]@{
Extension = $meta.name
Publisher = $meta.publisher
Version = $meta.version
}
}
} | Sort-Object Publisher | Format-Table -AutoSize
Write-Host "ACTION: Compare publisher list against your approved extension allowlist. Unapproved AI/copilot extensions are a repo-leak vector." -ForegroundColor Yellow
} else { Write-Host "No VS Code extensions directory found." }
Write-Host "`n=== [2/4] Git Config Injection Check (repo-level URL rewrites & credential helpers) ===" -ForegroundColor Cyan
$repoRoots = @("$env:USERPROFILE\source", "$env:USERPROFILE\repos", "$env:USERPROFILE\dev", "$env:USERPROFILE\Documents")
foreach ($root in $repoRoots) {
if (Test-Path $root) {
Get-ChildItem $root -Recurse -Force -Depth 3 -Filter "config" -ErrorAction SilentlyContinue |
Where-Object { $_.DirectoryName -like "*\.git*" } | ForEach-Object {
$content = Get-Content $_.FullName -Raw
if ($content -match 'insteadOf|credentialhelper|http\.proxy|core\.sshCommand') {
Write-Host "REVIEW: $($_.FullName)" -ForegroundColor Red
$content | Select-String -Pattern 'insteadOf|credentialhelper|http\.proxy|core\.sshCommand' -AllMatches |
ForEach-Object { Write-Host " $($_.Line.Trim())" }
}
}
}
}
Write-Host "`n=== [3/4] Custom URI Protocol Handlers (one-click execution surface) ===" -ForegroundColor Cyan
Get-ChildItem "HKLM:\SOFTWARE\Classes" -ErrorAction SilentlyContinue |
Where-Object { $_.Property -contains "URL Protocol" } |
ForEach-Object {
$shellCmd = (Get-ItemProperty "$($_.PSPath)\shell\open\command" -ErrorAction SilentlyContinue).'(default)'
if ($shellCmd -match 'powershell|mshta|wscript|cmd\.exe|curl|rundll32') {
Write-Host "SUSPICIOUS HANDLER: $($_.PSChildName) -> $shellCmd" -ForegroundColor Red
}
}
Write-Host "ACTION: Investigate any flagged handler. Legitimate handlers point to installed application binaries, not script engines." -ForegroundColor Yellow
Write-Host "`n=== [4/4] ASR Rule Status (blunts browser/office-spawned payloads) ===" -ForegroundColor Cyan
$asrRules = @{
"d4f940ab-401b-4efc-aadc-ad5f3c50688a" = "Block Office apps from creating child processes"
"26190899-1602-49e8-8b27-eb1d0a1ce869" = "Block Office communication apps from creating child processes"
"56a863a9-875e-4185-98a7-b882c64b5ce5" = "Block abuse of exploited vulnerable signed drivers"
"e6db77e5-3df2-4cf1-b95a-636979351e5b" = "Block persistence through WMI event subscription"
}
$current = (Get-MpPreference).AttackSurfaceReductionRules_Ids
$actions = (Get-MpPreference).AttackSurfaceReductionRules_Actions
for ($i=0; $i -lt $current.Count; $i++) {
$id = $current[$i]
if ($asrRules.ContainsKey($id)) {
$state = switch ($actions[$i]) { 0 {"DISABLED"} 1 {"Block"} 2 {"Audit"} 6 {"Warn"} default {"Unknown"} }
Write-Host ("{0}: {1}" -f $asrRules[$id], $state) -ForegroundColor ($(if($actions[$i] -eq 1){"Green"}else{"Yellow"}))
}
}
Write-Host "ACTION: Set child-process ASR rules to Block mode on endpoints where workflow testing confirms low impact." -ForegroundColor Yellow
Write-Host "`nAudit complete. Route findings to your change-control and IR queues." -ForegroundColor Cyan
Remediation
There is no single patch for a poisoned search answer or an over-sharing coding assistant. Remediation here is architectural — closing the trust gaps these campaigns exploit.
Against AI search poisoning and fake-prompt (ClickFix) lures:
- Block the execution convergence point. The Sigma rules above work because every lure collapses into browser-spawned script execution. Enforce ASR child-process rules, and use WDAC/AppLocker to deny
mshta.exe,wscript.exe, andcscript.exefor standard users. - Disable or gate the Run dialog and paste-into-terminal workflows for standard users where feasible — ClickFix depends entirely on the user pasting a command.
- Route all DNS through protective resolvers and enable category blocking for newly registered domains; poisoned AI answers disproportionately link to infrastructure under 30 days old.
- Train against the specific lure: users must know that no legitimate vendor, search engine, or AI assistant will ever ask them to paste a command into Run or Terminal to "fix" something. Run a tabletop on exactly this scenario.
Against AI coding tool repository leakage:
- Allowlist extensions and AI assistants. Audit with the script above; remove anything not explicitly approved. Treat IDE extensions as software supply chain — pin versions, review publishers, monitor for updates that change permissions.
- Scope what the assistant can see. Configure AI tooling to exclude
.env, secrets directories,~/.ssh, and credential files from context. Where the vendor supports it, disable source-context telemetry or route it through your own tenant with contractual data-residency terms. - Secret-scan everything, continuously. Assume leakage has already happened: deploy pre-commit hooks and CI scanning (e.g., trufflehog, gitleaks), and rotate any credential that has ever existed in a repo reachable by an AI assistant.
- File-integrity monitor
.git/config, CI pipeline definitions, and package manifests on developer workstations and build agents. InjectedinsteadOfrewrites and poisoned install scripts are the quietest persistence mechanism in this class.
Against one-click code execution:
- Inventory and constrain URI protocol handlers (script step 3 above). Unregister handlers not required by business applications.
- Enforce SmartScreen/reputation-based download blocking and mark-of-the-web propagation controls; block execution of script content from the Internet zone.
- Alert on the behavior, not the lure — the KQL query above catches the chain regardless of which story-of-the-week delivered the click.
Verification cadence: re-run the audit script monthly and after any new AI tool deployment; review the KQL hunt weekly as a standing SOC query, not a one-time exercise.
The Bottom Line
This week's roundup is a reminder that the highest-yield attacks no longer announce themselves as attacks. They arrive as the update your user expected, the answer the AI gave them, the tool their team already installed. You cannot patch reflexes — but you can instrument the moments where every one of these lures becomes execution: the browser spawning PowerShell, the curl process reading .git/config, the script interpreter that no developer launched. Build detection there, harden the trusted paths, and these campaigns stop being scary and start being telemetry.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.