On November 16, 2026, visitors to the websites of 178 organisations were served malicious JavaScript. None of those websites had to be breached. The attack came through Optimizely Web Experimentation, a widely used A/B testing tool, after an attacker slipped hostile code into customer projects. Every page that loaded the Optimizely snippet ran it.
If you run a website that loads third-party scripts, this is the supply-chain risk made real. This guide explains what happened, why a trusted vendor script is such a dangerous weak point, and how to audit your own site for the same exposure — before an attacker does it for you.
What Happened: 178 Organisations, One Vendor
Security researchers at Report URI checked 1,611 Optimizely snippets and found 188 infected ones, belonging to 178 organisations. They warned the real number was likely higher, because their scan could only cover the snippets they could reach. The campaign has been named OPTIMJACK.
The list of affected sites reads like a directory of the web's biggest names: Zoom, BBC, CNN, Salesforce, GitLab, IKEA, HSBC, Equifax, Air France-KLM, Ledger, Peacock, TalkTalk, Fox News, Fox Sports, FAZ, and the Sydney Morning Herald. Optimizely's own website and login page carried the malicious code too.
That last detail matters. This was not a breach of any one newsroom or bank. A single compromised vendor turned some of the most visited pages on the internet into malware dispensers, as The Register reported.
How the Attack Worked
According to Optimizely's incident notice, an unauthorised party exploited a vulnerability in the Experimentation account signup flow. The attacker then wrote malicious code into the Project JavaScript field of customer projects — custom code that runs on every page where the snippet loads.
That placement is what made the attack so effective. The poisoned file was still served from cdn.optimizely.com, still carried Optimizely's certificate, and still came from a host every affected site already trusted. Browsers had no reason to block it, and most security tools had no reason to flag it.
Report URI found three loader variants in the infected snippets:
- Plain script tag. Most snippets loaded the payload directly from 1688360[.]cc/track.js.
- Base64-hidden. The same URL was encoded in base64 and decoded with atob(), so a plain text search for the domain would miss it.
- Full inline copy. The entire payload was embedded in the page and run through eval, so it kept working even if the attacker's domain was blocked.
Three variants, one goal: survive as many different defences as possible. A site that blocked the domain still ran the inline copy. A site that searched its code for suspicious URLs missed the encoded one.
What the Malicious Payload Did
The payload, track.js, was a multi-purpose kit, and all of its parts were active at once. It replaced legitimate cryptocurrency wallet addresses with the attacker's — in page text, in forms, in links, in the clipboard, and in outgoing requests. Anyone copying a wallet address on an affected page could have sent funds to the attacker instead.
It also skimmed payment card details typed into forms, stole cookies, and took screenshots. And on iPhones and iPads it went further: it loaded a second file, boot.js, then an exploit chain inside a hidden iframe, delivering the Coruna and DarkSword iOS exploit kits.
Comments in the kit itself say iOS 18.7.3 and 26.3 and later are patched. On devices running iOS 18.6 or earlier, affected pages reloaded every 60 seconds to retry the exploit. Security Affairs has the full technical breakdown of the campaign.
The money trail shows how fast this moved. By 2:25 p.m. ET (7:25 p.m. UTC) on November 16 — within roughly nine hours — about $7,040 had landed in the attacker's wallets. The payload was rebuilt 26 times during the day, a sign the attacker was actively tuning it as defenders responded.
The Timeline: Hours of Exposure
| Time (Nov 16, 2026) | What was known |
|---|---|
| 2:25 p.m. ET / 7:25 p.m. UTC | About $7,040 in attacker wallets within roughly nine hours |
| 3:56 p.m. ET / 8:56 p.m. UTC | 169 snippets still contained the malware |
| 4:52 p.m. ET / 9:52 p.m. UTC | Only TalkTalk's snippet still contained the malware |
| 8:02 p.m. ET / 1:02 a.m. UTC Nov 17 | Optimizely posted its incident notice; status listed as Monitoring |
Cleanup moved quickly once the campaign was public, but visitors who loaded an affected page during those hours ran the attacker's code in their own browsers. The gap between discovery and cleanup is the window that matters, and it is measured in hours, not minutes.
The Base64 Trick: How the Loader Hid in Plain Sight
One loader variant deserves a closer look, because it defeats the most obvious defence: searching your code for bad domains. Instead of writing the attacker's URL in plain text, the snippet stored it as a base64 string and decoded it at runtime with atob(). A text search for the domain name finds nothing, because the domain name never appears.
Here is the same trick with a harmless example, so you can see exactly how it works. This base64 string:
aHR0cHM6Ly9leGFtcGxlLmNvbS90cmFjay5qcw==
decodes to:
https://example.com/track.js
Now imagine that string sitting inside a vendor snippet, wrapped in atob() and passed to a script loader. Nothing in the page source looks like a URL. The browser decodes it, fetches the file, and runs it — all without a single readable domain name in the code.
If you ever find an encoded string you cannot explain in a script your site loads, decode it with a base64 decoder before deciding it is safe. Decoding takes seconds, and it turns an unreadable blob into a plain URL you can judge.
The reported indicator for this campaign was 1688360[.]cc/track.js, shown defanged here so it cannot be clicked or copied accidentally. If that string — or its base64 form — appears anywhere in your own code or logs, treat it as a compromise, not a curiosity.
Why a Trusted Script Is the Most Dangerous Kind
Most website security advice assumes the attacker comes through your own code: an unpatched server, a weak password, a vulnerable plugin. This attack inverted that. The sites did everything right on their own infrastructure, and the malware still arrived — because they trusted a vendor, and the vendor's platform was the way in.
That trust is structural. A testing or analytics snippet has to run JavaScript on your pages to do its job, which means it has the same power as your own code: it can read forms, change links, and send data anywhere. When you add a vendor script, you are not just adding a feature. You are giving a third party the keys to every page it loads on.
One defence people reach for is Subresource Integrity (SRI), which pins a script to a known hash. It does not fit here. SRI works when a file is supposed to stay identical, and vendor snippets like Optimizely's are meant to change — that is the point of an experimentation tool. You cannot pin a file whose contents are supposed to update.
What Stopped It: The CSP Finding
Report URI also tested the defences of the affected organisations themselves. The team crawled 256 affected organisations' own hosts and evaluated their Content Security Policies. Only 24 of them blocked the payload.
What worked was a restrictive script-src without 'strict-dynamic' or 'unsafe-eval', combined with a tight connect-src. In plain terms: a policy that said exactly which scripts may run, and exactly which hosts the page may talk to — with no broad permissions that let an injected script fetch its payload or phone home.
That is a demanding standard, and most sites do not meet it. But the finding is useful precisely because it is concrete: it tells you which two directives to check first. If you do not know what your site's security headers currently say, check your HTTP headers and read the Content-Security-Policy line as if an attacker were reading it. MDN's Content Security Policy guide explains each directive in detail.
Website Security Audit: A Checklist for Your Own Site
You do not need to be a security engineer to run a useful audit of your own site. Work through this checklist in order; each step takes minutes, and together they cover the exact weaknesses this attack exploited.
- Inventory every third-party script. Open your pages and list every script that does not come from your own domain: analytics, testing tools, chat widgets, ad tags, social embeds. If you cannot name what a script does, that is a finding, not a detail.
- Check your security headers. Look at your Content-Security-Policy: does script-src name specific hosts, or does it allow broad sources? Does it include 'unsafe-eval' or 'strict-dynamic'? Is connect-src restricted? Record what you find before changing anything.
- Decode anything encoded. Search your vendor snippets for base64 strings, atob(), and eval(). Decode suspicious strings before trusting them. A legitimate snippet rarely needs to hide a URL from a text search.
- Monitor vendor scripts for changes. A snippet that changes without a corresponding change on your side deserves a question. Ask your vendor whether they publish a changelog, and check the loaded file when something on your site behaves unexpectedly.
- Review who can change vendor projects. The attacker reached customer projects through a signup-flow vulnerability, but the lesson generalises: audit who has access to your testing and analytics accounts, remove ex-staff, and turn on multi-factor authentication everywhere it is offered.
- Patch fast, always. Days earlier, an Apache HTTP Server remote code execution flaw showed why patching speed matters — the Apache RCE fix was a version check away for most sites. A vendor incident is no excuse to let your own patching slip.
Run this audit once now, and repeat it whenever you add a new vendor script. The inventory step is the one most sites skip, and it is the one that would have told every affected organisation exactly where its exposure lived.
If You Use Optimizely
Optimizely's incident notice, posted at 8:02 p.m. ET on November 16 (1:02 a.m. UTC on November 17), said "an unauthorized party exploited a vulnerability in Experimentation and used it to add malicious JavaScript to some customer projects." The vendor says it fixed the vulnerability, removed the injected code, ended sessions, revoked tokens, and reset access.
No postmortem, affected-project count, or vulnerability details had been published at the time of writing, and the incident status was listed as Monitoring. If you run Optimizely Web Experimentation, do not wait for the postmortem to act:
- Open each project and inspect the Project JavaScript field for code you did not write.
- Rotate credentials and API tokens for the account, even if the vendor says sessions were ended.
- Check your own analytics and logs for requests to unfamiliar domains during November 16.
- Ask your Optimizely contact directly whether your projects were affected, and get the answer in writing.
One Careful Note on the Wider Reports
Some reporting has connected this incident to poisoned responses seen across four services around the same dates. Hudson Rock's infostealer reporting links incidents involving Kissmetrics on November 13, StorifyMe on November 13, Optimizely on November 16, and minute-ly on November 16. The evidence does not establish four separate vendor breaches, so treat the connection as an open question, not a conclusion — and do not repeat it as fact.
Frequently Asked Questions
Was my website affected by the Optimizely hack?
Only if your site loads the Optimizely Web Experimentation snippet and your project was among those modified. Check your Project JavaScript field for code you did not write, and ask Optimizely directly whether your projects were affected. Sites that do not use Optimizely were not exposed through this attack.
Should I run a malware scanner or set up CSP monitoring after this?
Both, in that order. A malware scanner checks whether your own files were changed, which matters if an attacker reached your server. CSP monitoring watches what your pages actually load in visitors' browsers, which is the layer this attack exploited. For third-party script risk, the browser-side view is the one that would have caught it.
Does a Content Security Policy stop supply-chain attacks?
It can, if it is restrictive enough. In this incident, only 24 of 256 tested organisations had a policy that blocked the payload. A restrictive script-src without 'strict-dynamic' or 'unsafe-eval', plus a tight connect-src, stopped it. A permissive policy with broad allowances would not have helped.
Why doesn't Subresource Integrity fix this?
SRI pins a script to a fixed hash, so the browser refuses to run it if the file changes. That works for libraries that never change. Vendor snippets for testing and analytics are designed to change — new experiments, new configuration — so pinning them would break the tool. CSP and vendor monitoring are the fitting controls here.
What should visitors do if they loaded an affected page on November 16?
Update your iPhone or iPad to iOS 18.7.3 or 26.3 or later if you have not already, since earlier versions were the target of the exploit chain. Check recent crypto and card transactions for anything you do not recognise, and consider changing passwords for accounts you used on affected sites that day.