Blog / Threat Analysis

ClickFix — A TLCTC Deep Dive

A causal analysis of the attack technique that bypasses a decade of exploit-prevention investment.

BK
Bernhard Kreinz
• • Updated • ~10 min read

ClickFix does not exploit an implementation flaw. That is the whole point. It exploits human psychology, legitimate operating-system functions, and intended code-execution capability. In TLCTC terms, it is the cleanest possible #9 → #1 → #1 → #7 chain — and the empirical case for treating Cluster #1 and interpreter-mediated #7 controls as first-class control surfaces.

Updated November 3, 2026: the chain is now written sequentially throughout, #9 → #1 → #1 → #7. It starts with the lure; the clipboard write fires on the victim's click, so it follows the lure rather than running in parallel with it, and the earlier (#9 + #1(clipboard)) form is withdrawn. The short form #9 → #1 → #7 used in the May 2026 original dropped one of the two #1 steps. The second #1 is the Run dialog itself; pressing Enter starts execution, as a double-click on a file does, and belongs to #7. TLCTC's ATT&CK mapping of T1204.004 now carries the same path.

The Statistical Reality

ClickFix was first observed in late 2023 and broke into mainstream telemetry in early 2024. Twelve months later, the numbers are difficult to dismiss:

47% of initial accesses attributed to ClickFix in Microsoft's 2025 reporting
500%+ rise in ClickFix detections (ESET, late 2024 → mid 2025)
#1 initial-access method (Microsoft Defender Experts 2025), ahead of traditional phishing at 35%
3+ OS Windows, macOS (AMOS), and Linux variants observed

The technique is operator-agnostic. Russia-linked APT28 and Iran-linked MuddyWater have adopted it alongside commodity infostealer affiliates. Payloads observed in 2024–2025 include Lumma, NetSupport RAT, AsyncRAT, XWorm, DarkGate, Latrodectus, MintsLoader, AMOS, and Rhadamanthys — i.e. the entire mid-tier of the criminal ecosystem has standardised on it.

How ClickFix Works

The mechanism is almost embarrassingly simple:

  1. The user lands on a malicious page (compromised site, malvertising, phishing link, or SEO poisoning).
  2. The page displays a fake but credible UI element: an anti-bot CAPTCHA, a "your browser needs to verify you are human," a fake Cloudflare challenge, a fake Windows update prompt, or a fake error dialog.
  3. Embedded JavaScript silently writes an attacker-supplied command to the clipboard via the Clipboard API — typically triggered by the user's click on a "verify" button.
  4. The page then instructs the user, step by step: "Press Win + R, then Ctrl + V, then Enter." On macOS the same flow targets Terminal, often abusing the applescript:// URI scheme.
  5. The pasted command executes. It is usually a PowerShell, mshta, or cmd one-liner that fetches a remote payload — increasingly fileless, loaded directly into memory via LOLBins such as powershell.exe, msbuild.exe, or regasm.exe.

No browser exploit. No kernel CVE. No credential theft. No malicious attachment opening through an Office macro. The user is the execution primitive.

The TLCTC Causal Map

At top level the path is canonical and minimal:

#9 ||[human][@External→@Org]|| → #1 → #1 → #7

That is:

  • #9 Social Engineering — generic vulnerability: Humans can be influenced into unsafe actions or decisions. The lure manipulates the user into believing a "fix" is required. Everything starts here.
  • #1 Abuse of Functions, twice — generic vulnerability: The inherent trust, scope, and complexity designed into software functionality and configuration. First the Clipboard API: the victim's click lets the page write the attacker's command to the clipboard, exactly as designed. Then the Run dialog: the victim opens it and pastes the command in, and it accepts the command exactly as designed. Pressing Enter is not part of this step.
  • #7 Malware — generic vulnerability: The software environment's designed capability to execute potentially untrusted foreign code. The #7 step starts when the victim presses Enter, the same act as the double-click that opens a malicious file. Foreign attacker-authored code is then executed via Windows' or macOS's intended script/binary execution paths. The trusted interpreter it launches stays a useful LOLBin control surface, but the execution is #7 (R-EXEC).

What is structurally interesting is what is not in this path. ClickFix needs:

  • No #2 (no server-side code flaw exploited)
  • No #3 (no browser or client CVE exploited)
  • No #4 (no stolen credential for initial access)
  • No #5, #6, or #8
  • No automatic #10 merely because the lure is hosted on a compromised legitimate site. A compromised site, ad network, or CDN is usually transit/topology; #10 applies only at a true Trust Acceptance Event where the victim organization accepts third-party output as authoritative.

Supply-chain boundary: If the lure is relayed through a compromised legitimate website, annotate that relay with the v2.1 Transit Boundary Operator ⇒, for example #9 ||[human][@Attacker⇒@CompromisedSite→@Victim]|| → #1 → #1 → #7. The transit operator captures exactly the semantics required here: passage through third-party infrastructure with no Trust Acceptance Event. Do not classify it as #10 unless a TAE is actually exploited.

An entire decade of vulnerability-management, browser-sandboxing, and exploit-mitigation investment is bypassed because the attacker never touches an implementation vulnerability in the traditional CVE sense. The causal weight has been shifted to the boundary between the human and the legitimate function.

The Forensic Decomposition

Top-level #9 → #1 → #1 → #7 names the causes; it hides only the second #7. For incident response and detection engineering, the maximally useful granularity is:

#9 → #1(clipboard) → #1(Run) → #7(PS command/FEC) → #7(payload)

This is five discrete events in a known order: the #9 lure, the #1 clipboard write that the victim's click triggers, the #1 Run dialog that accepts the pasted command, then #7 interpreter-hosted command execution, which starts when the victim presses Enter, then #7 downstream payload execution. Each event has its own telemetry surface and control mapping.

#9 Social Engineering lure UI #1 Clipboard API write on click #1 Run dialog command pasted #7 PowerShell command/FEC #7 Malware stealer / RAT click sec–min Enter ~1s Five-event forensic decomposition, sequential throughout, with velocity annotations

Step-by-step with telemetry

Step Cluster Mechanism Primary telemetry
1 #9 Lure UI in browser, fake CAPTCHA / error / update prompt DNS resolutions, HTTP referers, browser history, JS console (if forensic image)
2 #1 JavaScript navigator.clipboard.writeText() on user click Browser policy logs, Clipboard API audit (where instrumented)
3 #1 Victim opens the Run dialog (Win+R) and pastes the command; the dialog accepts it as designed Little of its own: the traces appear when Enter is pressed (step 4)
4 #7 Victim presses Enter; powershell.exe starts and interprets attacker-controlled command text or script content via -EncodedCommand / -c / -NoP -W Hidden HKCU\…\Explorer\RunMRU, Sysmon EID 1 with ParentImage=explorer.exe, PS EID 4104 (ScriptBlock), 4103 (pipeline), AMSI events, PSReadLine history, command-line audit
5 #7 Foreign payload — Lumma, NetSupport, AsyncRAT, etc. — loaded in memory or to disk EDR behavioral alerts, memory injection signatures, C2 beacon traffic, AV signatures (if disk-resident)

Why the Operators Matter

The whole chain is written with the sequential operator →. The May 2026 original wrote the first event as (#9 + #1(clipboard)) with the parallel operator; that form is withdrawn. The reasoning:

  • → from the lure to the clipboard write. The clipboard write fires when the victim clicks the lure's "verify" button, so the lure comes first and enables the write. The order is known, and + is reserved for genuinely independent concurrent actions.
  • Boundary operators. The #9 step carries the human boundary ||[human][@External→@Org]||, as every bridge step does. Transit (⇒) is added only when the lure is relayed through third-party infrastructure such as a compromised site. The clipboard write needs no intra-system boundary (|[type][@from→@to]|): it stays inside the user's browser session.
  • → through the rest of the chain. The paste into the Run dialog, the Enter that starts PowerShell, and payload execution are strictly ordered, with sub-second to second-scale latencies.

The Execution Boundary: #1 Run Dialog, #7 from Enter

The cleanest principled question in the chain is whether the PowerShell step belongs to #1 or to #7. Under strict TLCTC, the answer depends on the atomic action being classified.

#1(Run dialog, command pasted) → #7(Enter: PS command/FEC) → #7(downstream payload)

The Run dialog is #1: the attacker gets the command into a legitimate operating-system function without an implementation flaw. Pressing Enter is where execution starts. It is the same act as the double-click that opens a malicious file (T1204.002, #9 → #7), so it belongs to #7, not to the dialog. PowerShell hardening remains operationally important, but once powershell.exe interprets attacker-controlled command text, script bytes, or encoded content, Foreign Executable Content is executing through a designed execution capability. R-EXEC therefore requires #7 to be recorded.

This avoids the misleading shortcut #1(PS LOLBin) as a cluster label. The LOLBin observation is still useful as telemetry and control language, but it is not allowed to suppress the #7 execution step.

Correct convention: Use #1 for the Run dialog that accepts the pasted command and #7 from the moment Enter starts the interpreter-hosted execution of the attacker-controlled command. If a later stealer, RAT, loader, or script executes as a distinct payload, record another #7 step.

This rule applies regardless of payload character. A short stager such as IEX(IWR ...) and a self-contained malicious script supplied via -EncodedCommand both register a #7 at the moment PowerShell interprets the attacker-controlled FEC. Whether the chain contains one #7 or two #7 steps depends only on whether a distinct downstream payload subsequently materialises — not on whether the PowerShell step itself counts as #7. It always does, once attacker-controlled command, script, or encoded content is interpreted by a designed execution capability.

The chain therefore has two valid canonical forms, plus one variant:

#9 → #1(clipboard) → #1(Run) → #7(PS)                          // self-contained PS payload
#9 → #1(clipboard) → #1(Run) → #7(PS) → #7(payload)            // stager + downstream payload (most common)
#9 → #1(Run) → #7(PS)                                       // command shown on the page and copied by hand: no clipboard write

The five-event diagram earlier in this analysis depicts the second, more frequent form. The first form is structurally identical up to the point at which PowerShell interprets the supplied content; whether a second #7 follows is an empirical question about the specific campaign, not a framework decision. The same holds for the clipboard step: record it only where the page wrote the clipboard. The FileFix variant, which has the victim paste into the Explorer address bar instead of the Run dialog, has the same shape; only the function that accepts the paste changes.

Optional Bow-Tie Annotations: DREs

The ClickFix chain itself is a cause-side path. Data Risk Events should be appended only where the executed payload creates them; they are not standalone threat steps.

#7(infostealer) + [DRE: C] → #4(stolen credentials used)
#7(ransomware) + [DRE: Ac]

Credential acquisition remains the outcome of the enabling step and may carry + [DRE: C]. Credential use or presentation is a separate #4 step. Ransomware-style file encryption is Loss of Accessibility (Ac) unless the system or service itself becomes unavailable.

The Defensive Surface, Cluster by Cluster

ClusterStepControl families that actually bite
#9 Lure User awareness training (low–medium efficacy), browser anti-phishing reputation lists, ad-blocking, DNS filtering
#1 (clipboard) JS clipboard write Browser Clipboard API permissions (browser-vendor responsibility), enterprise browser policies that prompt on programmatic clipboard writes
#1 (Run) Win+R dialog, paste Group Policy disabling the Run dialog (NoRun)
#7 (PS command/FEC) Enter, PowerShell interpreter execution AppLocker / WDAC restricting which binaries explorer.exe may launch, Constrained Language Mode, ScriptBlock Logging (4104), Module Logging, AMSI, WDAC policy on PowerShell, command-line audit, JEA
#7 (payload) Stealer / RAT / loader / ransomware payload EDR behavioral detection (LOLBin → network → injection chain), egress filtering, application allowlisting, memory protection

The pattern is informative. The leftmost cluster (#9) has weak controls of high uncertainty. The rightmost payload #7 has the most mature commercial defenses (EDR). The middle band — the #1 function abuses plus the interpreter-hosted #7 step — is where many organisations are structurally underprotected, because it requires platform-level engineering (GPO, WDAC, ConstrainedLanguageMode, AMSI, script logging) rather than tool procurement alone.

ClickFix as a Control-Library Test

One of TLCTC's claims is that a defensible control library must cover all ten clusters as cause-side controls in the bow-tie. ClickFix is the empirical case that operationalises this claim. An organisation that has invested heavily in #2/#3 prevention (patch management, WAFs, browser isolation, vulnerability management) but treats #1 as a residual category — i.e. assumes "abuse of legitimate function" is an acceptance issue rather than a control surface — will be defeated by ClickFix with no compensating control to fall back on except late-stage #7 detection.

ClickFix is the purest demonstration that #9 → #1 → #1 → #7 alone is sufficient to compromise a modern endpoint. Every cluster the technique does not use is a cluster on which exploit-era control investment has been concentrated.

This re-weights the case for treating Cluster #1 — abuse of functions — as a first-class control surface with its own engineering programme, not a footnote under "user behaviour."

MITRE Anchor and Cross-Framework Position

ClickFix is catalogued in MITRE ATT&CK as T1204.004 — User Execution: Malicious Copy and Paste, under the Execution tactic (added 18 March 2025). TLCTC's ATT&CK mapping classifies it as #9 → #1 → #1 → #7, the same path as this analysis (until November 2026 the mapping read #9 → #7). ATT&CK bundles several causal steps that TLCTC separates: the human lure (#9), the clipboard and Run-dialog function abuse (#1), and the PowerShell / payload execution steps (#7). Downstream ATT&CK techniques such as T1059.001 PowerShell, T1218 Signed Binary Proxy Execution, and T1055 Process Injection should be decomposed by the same rule: feature/dispatch abuse without FEC is #1; attacker-controlled command, script, module, or binary execution is #7.

This is one of the cases where the two frameworks are commensurable rather than competing: MITRE provides the technique-level catalogue of what attackers do, TLCTC provides the causal taxonomy of which generic vulnerability each atomic action abuses. ClickFix is a clean joint case precisely because TLCTC prevents the "execution" label from hiding the #9 → #1 → #1 → #7 cause chain.

Takeaway

ClickFix is not a clever new exploit. It is the operational confirmation that an attacker who has access only to social engineering, legitimate OS functions, and a malware payload — the minimum-viable causal chain of #9 → #1 → #1 → #7, three clusters in four steps — already has everything needed to compromise endpoints at industrial scale. Microsoft's 2025 reporting places it as the most common initial-access method observed by its Defender Experts team, ahead of traditional phishing; it is being adopted by both APTs and commodity actors; it is portable across Windows, macOS, and Linux.

For defenders, the implication is structural rather than tactical. Investments in browser-level clipboard policy, GPO restriction of the Run dialog, PowerShell hardening (ConstrainedLanguageMode, ScriptBlock Logging, AMSI, WDAC), and EDR behavioural detection on the LOLBin → network → injection chain together cover the entire ClickFix path. None of these are exotic; many are free. But they require treating Cluster #1 and interpreter-mediated #7 as primary control surfaces, not residual categories — and that is the shift ClickFix forces.

References

References used in this analysis: Microsoft Digital Defense Report 2025, Microsoft Security Blog (Aug 2025), Palo Alto Unit42 (Aug 2025), Group-IB (March 2025), ESET (2025 telemetry), Darktrace (June 2025), FortiGuard Labs (Aug 2025), Malwarebytes (Nov 2025), ReliaQuest / Cybersecurity Dive (March 2026), MITRE ATT&CK T1204.004 (added 18 March 2025).

TLCTC framework: tlctc.net · cause-oriented threat taxonomy across 10 clusters.