Executive Overview: A Quiet, High-Impact Infiltration
On November 16, a sophisticated supply chain attack rippled across the digital landscape, impacting nearly 200 high-profile organizations—including industry giants like Zoom, the BBC, CNN, Salesforce, and GitLab. The breach occurred within Optimizely Web Experimentation, a popular platform used by marketers and product teams to conduct A/B testing and personalize website experiences.
By exploiting a specific vulnerability in the platform’s account signup flow, an unauthorized actor gained the ability to inject malicious JavaScript into customer projects. Because Optimizely snippets are loaded directly from the company’s Content Delivery Network (CDN), the malicious code was executed with the implicit trust of the victim’s domain. This allowed the attacker to bypass traditional security perimeters, harvesting sensitive data, hijacking cryptocurrency transactions, and deploying exploit kits to mobile device users.
This incident serves as a sobering reminder of the inherent risks associated with third-party vendor integrations. Even with robust internal security, companies remain vulnerable to the "trusted source" paradox, where malicious payloads are delivered via the very platforms designed to enhance user experience.
Detailed Chronology: The Lifecycle of the Attack
The breach was not a long-term, persistent threat, but rather a rapid, targeted injection that occurred over the course of approximately 19 hours on November 16.
Early Detection and Escalation
Security researcher Scott Helme, founder of Report URI, first identified anomalous code within an Optimizely snippet at 4:21 a.m. UTC. As his team began to cross-reference the suspicious scripts, the scale of the incident became immediately apparent. The malicious payload was not a generic piece of malware; it was a highly functional, multi-stage script designed to perform specific malicious actions based on user behavior.
The Timeline of Malice
Throughout the day, the attacker maintained their foothold, with the activity peaking in intensity by early afternoon. By 1:43 p.m. UTC, the script was actively monitoring website forms for credit card information, expiration dates, and CVVs. It also began systematically replacing legitimate cryptocurrency wallet addresses with the attacker’s own, a classic "cryptojacking" technique.

By 7:25 p.m. UTC, the attacker had successfully siphoned approximately $7,040 in cryptocurrency. The assault concluded shortly thereafter, with all infected snippets reportedly cleaned by 11:11 p.m. UTC on the same day. While the duration was brief, the potential for data exfiltration—including session cookies and screen captures—remains a significant concern for the affected organizations.
Supporting Context & Metrics: The Mechanics of the Breach
The success of this attack relied heavily on the architecture of Optimizely’s service, which allows clients to insert "Project JavaScript." This feature is intended to give teams the flexibility to run custom code for experiments across their entire site.
The "Trusted Domain" Fallacy
When a customer installs Optimizely, they point their browser to cdn.optimizely.com. Because this domain is trusted, web browsers allow scripts from it to execute without restriction. The attacker weaponized this by creating malicious code within the Project JavaScript section of compromised accounts. Because the malicious payload was injected into the legitimate snippet, the origin remained verified. To a website’s security policy, the malicious code appeared to be just another piece of the client’s own experiment logic.
Data Harvesting and Exploit Delivery
The malicious script was sophisticated enough to perform "context-aware" theft. It was designed to:
- Intercept Payment Data: It monitored form fields for payment information, though it was unable to reach data processed through secure, third-party iframes (such as Stripe or Adyen).
- Exfiltrate User Context: The script captured URLs, non-
HttpOnlycookies, and even screenshots of the page, sending this data back to the attacker’s command-and-control server. - Mobile Exploitation: For users on older iOS devices, the script attempted to load the Coruna and DarkSword exploit kits, which are designed to leverage known vulnerabilities in outdated mobile software.
The Failure of Content Security Policies (CSP)
Perhaps the most alarming aspect of this breach was the limited effectiveness of Content Security Policies (CSP). Report URI’s analysis of 159 affected organizations revealed that:
- 68 organizations had no CSP whatsoever, offering zero resistance to the malicious script.
- 50 organizations had misconfigured CSPs that explicitly permitted the malicious code to execute and transmit sensitive data to the attacker’s server.
- Only 24 organizations (15%) successfully blocked the execution. These organizations were distinguished by their use of highly restrictive
script-srcdirectives that limited execution to a narrow set of trusted hosts.
Many organizations had adopted the strict-dynamic directive, which, while useful for managing complex third-party dependencies, effectively granted the malicious code a "pass" once it was inside the Optimizely snippet. Similarly, the use of unsafe-eval—often recommended to support certain Optimizely features—allowed the attacker to execute inline code even when other protections were in place.

Official Statements: The Response from Optimizely
Optimizely’s response centered on containment and remediation. In a statement provided to BleepingComputer, the company confirmed that the breach stemmed from a vulnerability in their "Experimentation account signup flow."
"We have blocked access to the vulnerable path and deployed a fix," the company stated. Furthermore, they confirmed that they had "ended active sessions, revoked tokens, and reset access for affected user accounts."
While the company has been active in notifying affected customers, they have remained notably quiet regarding the specific technical details of how a signup-flow vulnerability could be used to manipulate existing customer projects. As of November 17, the incident was downgraded to "Monitoring" on their status page, signaling that the immediate threat had been neutralized. However, for the victims, the work of auditing their own environments has only just begun.
Future Outlook: Protecting Against Supply Chain Risks
The Optimizely incident serves as a critical case study for organizations regarding third-party vendor management. The traditional "allow-listing" approach—where a vendor’s domain is added to a security policy—is no longer sufficient when that vendor provides the capability to execute custom, user-provided code.
Necessary Defensive Actions
For any organization utilizing SaaS platforms with custom script capabilities, the following steps are now industry best practices:
- Rigorous Auditing of Project JavaScript: Teams should immediately review all custom scripts within their Optimizely projects. Search specifically for obfuscated strings like
atob((used to decode malicious payloads) and references to unknown external domains like1688360.cc. - Credential Hygiene: Rotate all API tokens, integrations, and user passwords associated with your Optimizely account. Review the change history logs to see who has made modifications to Project JavaScript and ensure only authorized personnel have write access.
- Hardening CSPs: Move away from overly permissive CSPs. Avoid
unsafe-evalandstrict-dynamicif possible, or at least restrict them to known, hashed script sources. A restrictiveconnect-srcpolicy is vital; it ensures that even if a script manages to run, it cannot "phone home" with sensitive data like cookies or payment information. - Treating "Trusted" as "Untrusted": Assume that any third-party script can be compromised. Implement subresource integrity (SRI) where possible, though this is difficult with dynamically generated CDN content. More importantly, limit the ability of third-party scripts to access sensitive page elements by keeping payment forms in isolated iframes.
Conclusion
The Optimizely breach was a masterful execution of a supply chain attack, highlighting the blurred lines between legitimate functionality and malicious intent. As SaaS providers continue to build increasingly complex and integrated platforms, the responsibility for security becomes a shared burden. For the 178 organizations impacted, the lesson is clear: your security is only as strong as your least-vulnerable vendor—and even then, you must be prepared for the moment that trust is broken. Moving forward, a "Zero Trust" approach to vendor-provided scripts will be the only way to prevent similar incidents from causing long-term damage to customer data and brand reputation.