When the Tool You Trust Becomes the Attack — Optimizely and the Client-Side Supply Chain Problem

Supply Chain Security Series

On November 16, 2026, visitors to the websites of the BBC, CNN, Zoom, Salesforce, Equifax, IKEA, and 172 other organizations spent roughly 19 hours loading hostile code — not because any of those organizations were breached, but because a tool they all trusted was. The attacker never touched their servers. They didn't need to.

What Optimizely Is and Why It Matters Here

Optimizely Web Experimentation is an A/B testing and website personalization platform. Organizations embed a small JavaScript snippet from Optimizely's CDN into their pages, and Optimizely handles the rest — serving different content to different visitors, measuring which version performs better, and running custom JavaScript across pages via a configuration field called Project JavaScript.

That last capability is the attack surface. Project JavaScript is a customization field that executes code on every page that loads the snippet. It's configured through Optimizely's platform console — often by marketing teams, not engineering — and the resulting code is served directly from cdn.optimizely.com with Optimizely's own TLS certificate.

On November 16, an attacker exploited a vulnerability in Optimizely's account signup flow to gain access to customer projects and inject a malicious loader into that field. The affected organizations didn't change a line of their own code. Their pages just kept loading Optimizely's snippet, the same way they always had, from the same domain they always trusted.

How the Attack Unfolded

The first injection appeared at 04:21 UTC in the BBC's Optimizely snippet. What started as a relatively simple crypto address swapper escalated through the day as the attacker pushed updated payloads. By 13:43 a card skimmer had been added. After 17:00 an iPhone exploit-kit routing stage was live. The attacker rebuilt the payload 26 times across three loader variants — a plain version, one with the payload URL hidden in Base64, and one with a full inline payload copy as a fallback. At least one script was re-infected after Optimizely began cleaning.

Mass cleanup didn't begin until around 20:40 UTC. Report URI's Scott Helme, who identified the attack, confirmed the last infected snippet was cleaned by 21:52.

The payloads were specific and effective:

Crypto address swapping: The clipper scanned page text, inputs, and textareas for wallet addresses on eight chains. It only acted near words like "wallet," "deposit," or "send," and intercepted clipboard copy events to swap addresses without triggering a separate permission prompt. Bitcoin and Tron addresses were checksum-validated before substitution; Ethereum got a prefix and length check.

Card skimming: Hooked form submissions and outgoing fetch/XHR requests, validated card number, expiry, and CVV, and exfiltrated them to an attacker endpoint. It could not reach fields inside hosted payment iframes — Stripe or Adyen checkout widgets were out of scope.

Data collection: Under certain conditions, collected the page URL, JavaScript-readable cookies, and a rendered screenshot of the page.

iPhone targeting: On iOS devices, routed browsers to exploit-kit infrastructure selected by iOS version.

By the time it was over, Report URI had tracked approximately $7,000 in wallet transfers. The number of payment cards and cookies stolen is unknown.

Why Existing Controls Missed It

This attack is a useful case study in why the standard enterprise security stack has a blind spot for client-side supply chain attacks.

Domain allowlists didn't help. The payload was served from cdn.optimizely.com — a domain every affected site had explicitly trusted. There was nothing to block.

WAFs and server-side tools never saw it. The traffic went from Optimizely's CDN directly to the visitor's browser. It never passed through any perimeter the affected organizations controlled.

SAST and code review didn't catch it. The code changed outside each organization's release process, through a marketing-team configuration panel. No pull request was opened. No pipeline was triggered. No reviewer was notified.

CSP performance was poor. Of 256 affected hosts reviewed, 68 had no Content Security Policy at all. Fifty had a policy that let both the payload delivery and the data exfiltration through. Only 24 actually blocked the payload. The gap between "has a CSP" and "has a CSP that works" is significant.

"The affected organizations did nothing unusual. They used a reputable tool, the way it was designed to be used." — Reflectiz research team

That framing is the point. The organizations that got hit weren't negligent. They were operating normally. The attack surface wasn't their code — it was their trust relationship with a vendor.

The Pattern This Belongs To

This is not a new class of attack. The Magecart campaigns that targeted British Airways and Ticketmaster in 2018 worked on the same principle: compromise a third-party script loaded by high-value sites, harvest payment data at scale from visitor browsers. The polyfill.io incident in 2024 — where a Chinese company acquired a widely-used JavaScript library and poisoned it — affected over 100,000 websites. The Optimizely attack is the 2026 iteration of a supply chain pattern that has been running for nearly a decade.

What changes between iterations is the scale and the sophistication of the payload. What doesn't change is the structural vulnerability: organizations load third-party JavaScript they don't control, from domains their browsers trust implicitly, running in the same execution context as their own code.

Every analytics tag, every A/B testing platform, every chat widget, every personalization engine on your website is a potential injection point for this class of attack. The question is not whether that risk exists — it does, by design — but whether your controls are built to address it.

What This Means for Healthcare

The Attack Surface Is Present

No healthcare organizations appeared in the confirmed list of 178 affected organizations. But the question isn't whether a healthcare organization was hit by this specific incident — it's whether the conditions for this class of attack exist on healthcare-managed websites. Patient portals, appointment booking pages, bill payment interfaces, and donor-giving pages commonly run the same category of tools: A/B testing platforms, chat and engagement widgets, analytics tags, and personalization engines. Any of them could be an Optimizely-equivalent in a future incident.

HIPAA Has an Implicit Web Tracking Problem Already

Healthcare is in an uncomfortable position with third-party web scripts specifically. The 2022–2024 HHS guidance on tracking technologies established that pixel-level analytics tools on authenticated patient pages can constitute impermissible disclosure of PHI. The Optimizely attack adds a second dimension: those same third-party scripts, if compromised, could actively exfiltrate whatever the JavaScript execution context can reach — including page content, form values, cookies, and screenshots. A card skimmer on a healthcare bill payment page doesn't just steal a credit card. It potentially captures enough context to constitute a HIPAA breach depending on what else is on that page.

Marketing Controls Are a Security Boundary

The most important operational lesson from Optimizely is about access control over SaaS consoles that can publish JavaScript to production websites. If a marketing team member can push code to your website through a vendor's platform without engineering review, that platform is a production deployment channel with no change management controls. Treating it otherwise is a governance gap. Healthcare organizations operating under change management requirements — whether from HIPAA Security Rule risk analysis obligations, SOC 2, or internal SDL programs — should be auditing which vendor consoles can inject JavaScript into production pages and who has access to those consoles.

The Controls That Actually Help

Three controls are worth prioritizing in response to this attack class:

Script inventory for production pages. PCI DSS 4.0 requirements 6.4.3 and 11.6.1 require organizations processing payment cards to maintain an inventory of all scripts on payment pages, with business justification and integrity assurance for each. That framework applies directly here. Healthcare organizations should conduct the equivalent inventory for any page that handles PHI, authentication, or payment — not just pages in formal PCI scope.

Content Security Policy, properly deployed. The CSP data from this incident is instructive: having a CSP isn't enough. Only 24 of 256 affected hosts had a policy that actually blocked the payload. A CSP that allows broad wildcard domains, or that lacks a `connect-src` directive covering data exfiltration endpoints, provides false assurance. CSP requires ongoing maintenance against the actual third-party domains your pages load.

SaaS console access control and change alerting. Any vendor platform that can modify JavaScript executing on your production website should be treated as a production system: MFA enforced, access scoped to minimum necessary, and change events alerted to security. The Optimizely attack required access to the Project JavaScript field — that's a configuration change that should have been auditable and alertable.

The Structural Problem Remains

Optimizely patched the signup flow vulnerability, removed the injected code, revoked tokens, reset access for affected accounts, and notified customers. The incident response was reasonable. But the structural problem — that organizations grant implicit execution trust to third-party CDN-hosted JavaScript as a normal operating condition — doesn't get patched by any single vendor fixing any single flaw.

The polyfill.io incident didn't end the practice of loading third-party scripts. The Magecart campaigns didn't end it. The Optimizely attack won't end it either. The business value of these tools is real, and the integrations are deeply embedded. What changes after each incident, if anything does, is the maturity of the controls organizations build around them. The script inventory. The CSP. The access controls on the consoles that can push to production.

That work isn't glamorous. But it's the gap this attack class exploits, every time.


This is an entry in the Supply Chain Security series. For related coverage on AI-generated code and software supply chain risk, see When AI Writes the Code, Who Checks the Supply Chain?


Key Links