Third-Party Code Is First-Party Risk: How the Optimizely Attack Hit 178 Trusted Websites

On November 16, 2026, visitors to some of the world’s most trusted websites, including BBC, CNN, Zoom, Salesforce, GitLab, Equifax, HSBC, and IKEA, were quietly served malicious code. Those organizations weren’t breached. Their servers were intact. A single third-party vendor they all shared had been.

The vendor was Optimizely, a widely used digital experience platform whose JavaScript snippets run on roughly 190,000 live websites. An attacker exploited a flaw in Optimizely Web Experimentation to inject malicious code into customer projects served from Optimizely’s own content delivery network. Because those scripts came from a trusted source, browsers and websites treated them as legitimate. They weren’t.

Security researcher Scott Helme and his team at Report URI identified 188 infected scripts across 178 organizations. The first injection appeared at 04:21 UTC. By 23:11 UTC the same day, all monitored files were clean, but in those roughly 19 hours, a remarkable amount of damage could have been done.

The payload was a Swiss army knife of browser-side maliciousness. A file called track.js swapped cryptocurrency wallet addresses for the attacker’s own in page text, forms, links, the clipboard, and outgoing requests. An address copied from one of these pages could already belong to the attacker by the time it was pasted into a wallet. A card skimmer, added at 13:43 UTC, captured card numbers, expiry dates, and CVVs from site form fields. The code exfiltrated cookies and screenshots. And for iPhone and iPad users, it loaded iOS exploit kits, Coruna for iOS 13 through 17 and DarkSword for iOS 18, via hidden iframes. By Monday evening, roughly $7,000 in cryptocurrency had reached the attacker.

Hudson Rock, which corroborated parts of the analysis, warned that blocking the attacker’s domain wasn’t enough. Some poisoned scripts had the full payload embedded locally, so the malware could execute even if the remote file failed to load.

Optimizely confirmed the incident, patched the vulnerability, and removed the injected code. The timeline was tight and the response was fast. But the architecture that made this possible is everywhere.

The Trust Problem

Here is what makes this incident so instructive: none of the affected organizations did anything wrong in the traditional sense. Their own code was secure. Their own servers were intact. They simply loaded a script from a vendor they trusted, a vendor whose CDN they had no reason to question, and that script turned hostile.

This is the core tension of modern web development. Every website today is assembled from dozens, sometimes hundreds, of third-party components: JavaScript libraries, analytics snippets, A/B testing tags, chat widgets, payment SDKs, CDN-hosted frameworks. Each one is a potential entry point. Each one extends your attack surface beyond your own code and into the security posture of every vendor in your supply chain.

The Optimizely attack demonstrates this with unusual clarity. A single optional field, intended for customer-provided JavaScript, became a conduit for card skimming, crypto theft, and exploit kit delivery across 178 organizations simultaneously. One compromise, 178 blast radii.

The lesson is straightforward: third-party code is first-party risk. Every script, snippet, and library you load belongs to your attack surface, and it needs to be treated with the same rigor as the code you write yourself.

Supply Chain Best Practices: A Layered Approach

No single control would have fully prevented this. But a layered, defense-in-depth strategy, one that assumes trust can be broken at any link, would have dramatically reduced the blast radius and accelerated detection. Here’s what that looks like in practice.

1. Inventory everything you depend on

You cannot protect what you cannot see. Maintain a continuously updated Software Bill of Materials (SBOM) that maps every component in your applications, including transitive dependencies and third-party scripts loaded at runtime. This gives you the visibility to answer a critical question the moment an incident breaks: Are we exposed?

Software Composition Analysis (SCA) is the cornerstone capability here. Veracode SCA automatically inventories every open-source and third-party component in your applications, maps your full dependency tree, and continuously monitors that inventory against live vulnerability databases and malicious-package feeds. When a supply chain incident hits, you know immediately whether you’re affected and where.

2. Block threats before they enter your pipeline

Detection after the fact is necessary but insufficient. The most effective supply chain defense stops malicious components from entering your development environment in the first place.

Veracode Package Firewall does exactly this, blocking malicious and risky packages before they ever reach your CI/CD pipeline. It monitors registries like npm and PyPI, enforces custom policies, and detects anomalies like typo-squatting and backdoored dependencies. While traditional SCA identifies vulnerabilities in packages already in use, Package Firewall stops threats at the point of ingestion, before they become your problem.

3. Monitor for emerging threats in real time

Supply chain attacks don’t wait for your scan schedule. When a new malicious package is published or a vendor compromise is disclosed, the window between awareness and action matters.

Veracode Software Supply Chain Intelligence (SSCI) provides real-time, actionable threat intelligence from a proprietary threat feed. It continuously monitors open-source registries, delivers immediate alerts on new malicious packages, and helps you maintain compliance with regulations like DORA and GDPR through customizable policies.

4. Assess your vendors and their vendors

The Optimizely attack underscores why third-party app risk management can’t stop at your own perimeter. You need to understand the security posture of every vendor in your supply chain, and continuously reassess as conditions change. A mature third-party app risk management program spans three layers: the device layer (where risk enters the pipeline through developer workstations), the repository layer (the central nervous system of software delivery), and the production layer (what’s actually exposed to attackers). Controls at each layer, from package ingestion policies and pre-commit scanning, to package firewalling and SBOM generation, to runtime monitoring and external attack surface management, limit blast radius and speed response when a shared service goes hostile.

This is also where consolidated tooling matters. Point-tool sprawl creates the very problems it’s meant to solve: alert noise, blind spots between tools, and friction that slows response. A consolidated application risk management platform that unifies SAST, DAST, SCA, container security, package firewall, and external attack surface management gives you a single view of risk across your entire application portfolio, with AI-powered remediation to close the loop.

Veracode’s Position

Veracode does not use Optimizely and is not affected by the Optimizely supply chain incident of November 16, 2026. There is no impact to Veracode products, platform services, or customer data. Through our third-party risk management program, we are also assessing our vendors for any exposure related to this incident.

The Bigger Picture for Optimizely Attack

The Optimizely attack will be cleaned up, patched, and, for a time, forgotten. But the pattern it represents is accelerating. Supply chain attacks scale effortlessly because they exploit the connective tissue of modern software: shared dependencies, trusted CDNs, ubiquitous third-party scripts. A single compromise cascades to every downstream customer, and the attacker never has to touch the victim’s infrastructure.

The organizations that weather these incidents best are the ones that have already accepted a difficult truth: your security perimeter extends to every component you load, every vendor you trust, and every script that runs in your users’ browsers. That’s why third-party code is first-party risk.

Want to get ahead of the next supply chain attack? Secure your software supply chain with Veracode.