BBC, CNN, Zoom and Salesforce 'Hacked'? What Actually Happened in the OPTIMJACK Attack
A compromise of Optimizely's third-party platform exposed visitors to malicious scripts across 178 organizations, highlighting the security risks of trusted website dependencies.

Claims that major organizations such as BBC, CNN, Zoom and Salesforce have been hacked or breached have been circulating following a major cybersecurity incident. While these organizations were indeed associated with the incident, the actual story is somewhat different from what these headlines might suggest.

On November 16, 2026, attackers exploited a vulnerability in Optimizely Web Experimentation, a third-party platform used by organizations to test and personalize their websites. According to cybersecurity researchers at Report URI, their investigation identified 188 infected JavaScript snippets associated with 178 organizations, including BBC, CNN, Zoom, Salesforce, IKEA, HSBC and Equifax.

So, were all these organizations actually breached?

Not in the conventional sense of their internal networks or databases being compromised. The attackers compromised a shared third-party service that these organizations relied on, allowing malicious code to be delivered through their website integrations and executed in visitors' browsers.

But what did the attackers actually achieve? The malicious scripts were designed to steal cryptocurrency, capture payment card details and collect accessible browser information. Researchers traced approximately $7,040 in cryptocurrency received by attacker-controlled wallets during the campaign. The scripts also attempted to collect card numbers, expiry dates and CVVs, although the total number of payment cards or cookies successfully exfiltrated could not be established. The attackers also attempted to deliver exploit kits targeting vulnerable iPhones and iPads.

The incident, known as OPTIMJACK, demonstrates how compromising a single trusted third-party dependency can expose visitors across hundreds of otherwise legitimate websites.

What Happened and How Did It Work?

Optimizely Web Experimentation enables organizations to perform A/B testing and personalize websites by integrating a JavaScript snippet, commonly delivered through its Content Delivery Network (CDN) at cdn.optimizely.com.

This snippet supports custom functionality through a feature called Project JavaScript, which allows code to execute on pages where the Optimizely integration is installed.

Attackers exploited a vulnerability in Optimizely's account signup process, allowing them to impersonate existing customer administrators without stealing their passwords. They then modified Project JavaScript in affected customer projects and injected malicious code.

When visitors opened affected websites, their browsers downloaded the modified scripts through Optimizely's legitimate infrastructure. The injected code acted as a loader, retrieving additional malicious JavaScript from attacker-controlled infrastructure.

The payload was designed to perform several malicious activities:

  • Cryptocurrency theft: Replace legitimate wallet addresses displayed on webpages or copied to the clipboard with attacker-controlled addresses.

  • Payment card skimming: Capture card numbers, expiration dates and CVVs entered into payment forms hosted directly on affected websites.

  • Cookie theft: Collect JavaScript-accessible cookies and, in certain circumstances, page URLs and screenshots.

  • Mobile exploitation: Attempt to deliver Coruna and DarkSword exploit chains targeting vulnerable iOS and iPadOS devices.

An important detail is that the initial malicious code was delivered through Optimizely's legitimate CDN using its valid security certificate. This was not a traditional CDN compromise or cache-poisoning attack. The attackers modified customer project code, and the CDN delivered that modified content through its normal functionality.

This is what makes OPTIMJACK a significant third-party software supply-chain attack.

Why Does This Incident Matter?

Modern websites rarely operate using only their own code. They depend on external services such as CDNs, analytics platforms, advertising scripts, tag managers, payment integrations and customer-experience tools.

These dependencies improve functionality and performance, but they also expand an organization's attack surface.

When third-party JavaScript executes inside a webpage, it can generally access the page's DOM and interact with information available to other scripts within that page. Consequently, compromising a trusted vendor can provide attackers with an opportunity to target visitors across multiple downstream websites.

CDNs make this particularly significant because they efficiently distribute content across geographically distributed infrastructure. When the content being distributed becomes malicious, that same delivery mechanism can help the attack reach a much wider audience.

The incident demonstrates that securing an organization's own servers and applications is not enough when external code is also executing in its users' browsers.

What Should Organizations Learn From This?

OPTIMJACK highlighted how certain browser security mechanisms can limit the impact of malicious scripts. Organizations should consider the following measures:

1. Isolate Payment Details Using Cross-Origin Iframes

The attackers' card skimmer could not directly access payment details entered into hosted Stripe and Adyen payment fields.

  • Why it works: These payment fields use cross-origin iframes. The browser's Same-Origin Policy prevents JavaScript running on the main website from reading information inside an iframe hosted on a different origin.

  • What to do: Use hosted payment fields or provider-hosted checkout instead of collecting card details directly through your website's forms.

2. Protect Session Cookies Using HttpOnly

The attackers attempted to collect browser cookies through JavaScript. However, cookies configured with HttpOnly cannot be read through document.cookie.

  • Why it works: The browser prevents client-side JavaScript from directly accessing HttpOnly cookie values.

  • What to do: Configure sensitive session cookies with HttpOnly, Secure and an appropriate SameSite policy.

Note: HttpOnly prevents direct cookie theft through JavaScript, but does not stop malicious scripts from performing actions through an already authenticated session.

3. Implement a Restrictive Content Security Policy (CSP)

The injected scripts attempted to load additional payloads from attacker-controlled domains and communicate with external infrastructure.

  • Why it helps: script-src restricts where JavaScript can load from, while connect-src controls outbound connections that could be used for data exfiltration.

  • What to do: Implement restrictive CSP rules, avoid unnecessary unsafe-eval permissions and monitor CSP violation reports. Do not blindly trust every third-party domain.

4. Monitor and Restrict Third-Party Dependencies

The attack exploited a trusted third-party platform to distribute malicious code across multiple organizations.

  • Maintain an inventory of external scripts, analytics tools, CDNs and integrations.

  • Monitor unexpected script modifications, changes to vendor configurations and suspicious outbound connections.

  • Apply MFA, least-privilege access and approval controls to third-party platforms that can modify production code.

  • Remove unnecessary third-party scripts, particularly from payment and authentication pages.

The key lesson: Third-party services should be treated as part of an organization's attack surface. A trusted vendor or approved integration can become an entry point when compromised.

Conclusion

OPTIMJACK is a reminder that an organization's security perimeter extends beyond its own infrastructure. Every third-party service, external script and software dependency introduces another layer of trust that must be managed.

A vulnerability in a single trusted vendor can potentially affect hundreds of downstream organizations without directly compromising their internal networks.

The security of a website depends not only on the code an organization develops and maintains, but also on the code it trusts and executes from others.

References and Further Reading

Sakar Poudel 18 November, 2026
Share this post
Archive
Sign in to leave a comment