2026-11-17 · 10 min read

Your Vendor Didn't Get Hacked. Their Dashboard Did.

Flat isometric diagram of one central control panel connected by thin indigo lines to many identical nodes, most lit violet, one green, with a few lines breaking away toward an unlit off-grid point.

The most dangerous script on your page is the one your company didn't write. On 16 November 2026, that script was a file on a CDN you already trusted, with a valid certificate, on a hostname that had been in your allowlist for years.

Here is the part worth sitting with: at 02:21 UTC, the BBC's Optimizely snippet was clean. By 04:21, it was loading a script from an attacker-controlled domain. Nothing on bbc.com changed that morning. No deploy. No pull request. No CI run. No DNS record touched on the BBC's own infrastructure. The file was still being served by Optimizely, exactly as it had been the day before.

What actually happened, briefly

Optimizely Web is an experimentation platform. Each customer embeds a small JavaScript file — a "snippet" — from Optimizely's CDN. That snippet contains Optimizely's own code, the customer's experiment definitions, and an optional field called Project JavaScript: a text box in the customer dashboard where you can write custom code that runs on every page.

An attacker got write access to that text box across a large number of unrelated customer accounts. The rest of each snippet was left untouched. The injected loaders came in three flavours: a plain script tag pointing at the attacker's domain, the same URL hidden in base64 and decoded with atob() at runtime, and a full inline copy of the payload that ran through eval if the external fetch was blocked. That third variant matters: if you cleaned up by blocking the domain, some pages kept working for the attacker.

The payload was not subtle. It swapped cryptocurrency wallet addresses across eight chains — in page text, in form fields, in links, in the clipboard on copy, in outgoing fetch and XHR requests, in window.open calls, and through the iOS share sheet. It skimmed payment cards with Luhn validation. It captured cookies and screenshots. On iPhones and iPads running iOS 18.6 or earlier, it delivered iOS exploit kits. By 21:52 UTC, mass cleanup had reduced infections from 169 snippets to one. Smartsheet's snippet was cleaned at one point and then re-infected, which tells you the attacker still had access while everyone was cleaning up.

The breach wasn't in the CDN. It was in a text field.

Report URI's write-up is blunt about this, and it is the single most useful sentence in the whole incident: Optimizely's CDN served exactly what it was given. This was not cache poisoning. There was no tampering in transit. The bytes were authentic.

So ask the design question instead. Why does a marketing configuration field accept arbitrary JavaScript? Because that is the product. Project JavaScript is remote code execution as a feature, with a UI, a support team, and an audit log you probably can't read. That is not a criticism of Optimizely specifically — every tag manager, every A/B testing tool, every chat widget, every session-replay vendor on your site holds the same primitive.

When you paste that tag into your template, you are not granting a vendor read access to your analytics. You are handing them a write credential into your production document object model — the live page your customers are looking at — for every visitor, forever, until someone removes the tag. That credential is more powerful than most of the ones in your secrets manager, and it almost certainly went through less review.

You are underwriting the tenant model, not the vendor's security score

Most vendor risk reviews measure the wrong thing. They ask whether the vendor has encryption, SSO, a SOC 2 report, a pen test cadence. Those are fine questions about the vendor's own perimeter. They say almost nothing about blast radius.

The real question is this: if the vendor's admin console were compromised at 4am, how many customers would change behaviour at the same moment?

If one principal can write to many tenants' projects, then one access path reaches everyone. The attacker here did not breach 178 companies. They breached one control plane with write access to 178 companies. Those are wildly different amounts of work, and only one of them fits in a single night.

That asymmetry is the modern supply-chain economics: the attacker needs one door, defenders need 178 independent detection stacks. Rank your third-party scripts by two attributes, not by how much data they store:

  • Can it execute arbitrary JavaScript in my page? Tag managers, testing platforms, personalisation, chat, consent banners with custom code fields, and anything with an "advanced" or "custom HTML" box.
  • Does a single principal span tenants? Look for cross-account admin roles, shared service accounts, agency access granted to multiple properties, and support tooling that can edit your config on your behalf.

Two yeses put a vendor in your highest review tier regardless of what data they hold. A vendor that stores your data in a shared database with row-level permissions has a very different failure mode from a vendor whose config field runs in your page for every visitor.

"Search for the attacker's domain" is not a detection strategy

The base64 and eval variants exist for one reason: to defeat the response most teams actually have, which is grepping logs for a domain name after someone else publishes it. Searching for the malicious hostname would have found roughly one of the three loaders.

The signals that would have caught this are structural, not string-based. Something changed inside a script you already trust. A new script started loading. A page started talking to a destination it has never talked to. Each of those is detectable if you are watching for it, and each of them is invisible if your monitoring stops at "is the hostname allowlisted."

A cheap control that most teams skip: hash the snippet content you actually receive, on a schedule, and alert when the hash changes. You will get false positives every time the vendor ships a legitimate update — that is the cost, and it is a real one. But a diff you look at is worth more than an allowlist you never revisit. The same applies inside the vendor: config changes that can execute code should generate a webhook you subscribe to, and if the vendor cannot produce one, that absence is a finding.

Where CSP actually earns its keep — and where it doesn't

Content Security Policy is a browser feature: a header where you declare which origins the page may load scripts from and talk to. It is the standard answer people reach for after an incident like this, and it is worth being honest about what it would have done.

It would not have prevented the injection. A hostname allowlist is useless when the malicious code arrives from a hostname you deliberately allowlisted — cdn.optimizely.com was on everyone's list, and it served the malware. Hashing the inline snippet fails the moment the vendor changes the snippet legitimately, which is constantly. Customers who served the snippet from their own subdomain, as Scheels and Vodafone Australia did, were affected too, because the content still came from the same vendor project. First-party hosting buys you nothing here.

Where CSP earns its keep is the second hop. The injected code still had to fetch its payload and still had to send stolen card numbers and cookies somewhere. A script-src and connect-src allowlist blocks both. It does not stop the injection; it stops the exfiltration and the follow-on tools. That is a smaller promise than the marketing suggests, and it is the one that holds up.

One more control that is easy to forget: the iOS exploit kits targeted devices on iOS 18.6 or earlier. Patching is a security control, and it is the one you control least on your customers' hardware.

Cleanup is not recovery

Read the timeline as an incident responder, not as a news reader. First injection at 04:21 UTC. First cryptocurrency sweep at 13:03 — nearly nine hours of live exposure. Card skimmer added at 13:43. Mass cleanup between roughly 20:40 and 21:10. At 21:52, one snippet was still infected.

The mass removal of the malicious code is a statement about the vendor's CDN. It is not a statement about your users. Wallets were already swept. Card numbers were already posted to an attacker's endpoint. Cookies were already captured, and captured session cookies can still be valid. Your incident clock starts at first injection — not at detection, and not at cleanup.

If you were in the affected set, the recovery list includes rotating sessions for the exposure window, treating the clipboard as a channel you may have corrupted for users, and communicating specifically enough that a customer who copied a wallet address that morning knows to re-verify it.

A four-question inventory you can run this week

You do not need a platform to start. Open your page templates and list every third-party origin that can execute JavaScript. Then ask four questions of each one.

  1. Can it run arbitrary code? If there is a custom HTML or custom JavaScript field anywhere in its dashboard, the answer is yes.
  2. Can one compromised principal reach many tenants? Ask the vendor directly. The quality of the answer tells you as much as the content.
  3. How would I know it changed tonight? If the answer is "I would read about it on Hacker News," your detection time is measured in hours, and so is your exposure.
  4. Can I remove it in one deploy, and have I tested that? A kill switch you have never pulled is a hypothesis, not a control.

The output of that exercise is a ranked list. Put the executable-plus-cross-tenant vendors at the top, give them change alerts, and put a CSP in enforcement mode — after a report-only ramp, so you learn what breaks before you break it.

The uncomfortable trade-off

None of this is free. Removing third-party JavaScript costs you experimentation velocity; the growth team loses the ability to ship a test on a Tuesday afternoon without an engineer. Moving to server-side experimentation helps a lot — the decision becomes a JSON payload your own code interprets, instead of a stranger's script executing in your page — but it takes real engineering and it narrows what non-engineers can do alone. Consolidating vendors reduces write paths, and you still will not get to zero if you run a modern marketing site.

The honest decision is not "trust no vendor." It is to notice that you have been treating a remote code execution channel as a line item in a marketing budget, and to start pricing it like what it is. The engineer who added that snippet was not being careless. Nobody told them they were handing out a write credential.

Key Takeaways

  • A third-party script tag is a write credential into your production DOM. Review it with the seriousness you give any credential that can execute code.
  • Blast radius beats security scores. Ask how many tenants one compromised principal can reach; that number is your real risk, not the vendor's certification list.
  • Allowlisting the domain is not detection. The malware came from an already-trusted host with a valid certificate, and two of three loaders defeated string searches.
  • CSP would not have stopped the injection, but it would have blocked the exfiltration. Enforce script-src and connect-src, and be precise about what that buys you.
  • Cleanup is not recovery. Nine hours passed between first injection and the first crypto sweep; rotate sessions and notify for the exposure window, not the detection window.
  • First-party hosting does not help. Sites serving the snippet from their own subdomain were hit identically, because the content still came from the vendor's project.

[ Call to action ]

Ready to scale your engineering team?

Tell us the roles you need to fill and we'll get back within 24 hours.