News and Notes from the Makers of Nexus | Sonatype Blog

Optimizely Attack Shows Why Supply Chain Ownership Matters

Written by Sonatype Research Team | November 17, 2026

TL;DR

  • Malicious JavaScript added to Optimizely projects reached sites across multiple industries, including technology, finance, retail, and media.

  • The injected JavaScript could swap cryptocurrency addresses, capture payment card information entered into website forms, collect some browser-accessible data, and attempt to deliver iOS exploit chains.

  • Optimizely said an attacker exploited a vulnerability, added malicious JavaScript to some customer projects, and that the company fixed the vulnerability, removed the code, and secured affected accounts.

  • Organizations using Optimizely should review project code and account access, investigate relevant logs, and assess potential exposure based on how their sites handled payment and session data.

  • The Optimizely incident shows how a change in one shared service can reach many organizations through software they already trust.

On November 16, 2026, malicious JavaScript was served to visitors of websites using Optimizely Web Experimentation. Report URI identified 188 infected snippets across 178 organizations, including major technology, media, retail, financial services, and travel companies.

A Shared Service Became a Shared Risk

Optimizely lets customers add custom JavaScript to their projects. In this incident, malicious code was placed in a project's custom-code field. The altered snippet was then delivered as part of the site's normal Optimizely integration, so the change did not have to pass through each customer's source repository or software build.

An unauthorized party exploited a vulnerability in Experimentation to add malicious JavaScript to some customer projects. Optimizely fixed the vulnerability, removed the injected code, secured affected accounts, and added protections against unauthorized code delivery.

This was not a case of attackers changing a customer's application source code or poisoning the CDN cache. The code was added to project settings and delivered as part of a service those websites relied on. An organization can secure its own code and infrastructure while still depending on external services that influence what reaches users.

The Payload Turned Shared Dependence Into Shared Exposure

The injected code used a loader to bring additional JavaScript into the page. Researchers observed multiple loader versions, including one that obscured the external address and another that carried an inline fallback.

That meant blocking one destination alone might not remove every way the code could run.

The payload combined several behaviors:

  • Cryptocurrency address swapping: The script could replace cryptocurrency addresses in page content and during copy actions, potentially redirecting transfers. Transactions to attacker-controlled wallets were confirmed.

  • Payment-card skimming: The code looked for card numbers, expiration dates, and security codes submitted through site-controlled forms. It could not access card fields inside cross-origin payment-provider iframes. The available reporting does not establish how many card details were captured.

  • Browser data collection: The script could send page URLs, screenshots, and cookies available to JavaScript. Cookies marked HttpOnly are not available through document.cookie.

  • iOS exploit delivery: On Apple mobile devices, the script attempted to load Coruna and DarkSword exploit chains. Researchers have not established how many devices, if any, were successfully compromised.

The confirmed cryptocurrency transactions show that at least one part of the operation had financial impact.

These capabilities show why teams need to understand not only what code a service is expected to run, but also what that code can access and how changes to it are controlled.

Integrity and Intelligence Must Cover the Full Path

Component intelligence helps teams identify the software they use, understand its role, and assess its known risks. Artifact integrity addresses a different question: whether the software moving through development and delivery is still the expected artifact. Both matter because organizations need context about their components and confidence in what they build and distribute.

The Optimizely incident exposes a gap between those controls and what happens in production. The malicious code was added through a third-party project setting and delivered to visitors' browsers. It did not need to enter a customer's source repository or change a locally built artifact. A package inventory or artifact check would not, by itself, show whether a vendor-managed script had changed.

That doesn't make component intelligence or artifact integrity less relevant. It means organizations need to understand the scope of each control and account for the code paths it does not cover. Alongside knowing which components enter software and verifying the artifacts teams release, organizations need visibility into the external services that can change code running on their sites.

Software Supply Chain Ownership Is an Operating Model

Organizations using Optimizely Web should consult Optimizely's incident update for current information and use their project and access records to determine whether their sites were affected.

More broadly, this incident shows why responsibility for software inputs and services needs to be shared across development, platform, security, and web teams. Those teams need a common understanding of what their software depends on, how those dependencies reach production, and who is accountable for changes along the way.

Owning the software supply chain means understanding what is being shipped and what external code can become part of the software customers use. Component intelligence, artifact integrity, and runtime visibility each help address a different part of that responsibility. For more on Sonatype's approach, check out our software supply chain security solution.