Optimizely Supply Chain Attack: What the Zoom and CNN Incident Teaches Us
Last updated November 17, 2026. This is a developing story and figures may change.
TL;DR
- What happened: On November 16, attackers injected malicious code into Optimizely-hosted scripts. 178 organizations, including Zoom, CNN, and HSBC, served it to visitors from a domain they already trusted.
- What it did: It swapped crypto wallet addresses, skimmed card data, and routed iPhones to exploit-kit infrastructure.
- Why defenses missed it: The code came from a trusted CDN and changed outside each site’s release process. Of 256 hosts reviewed, 68 had no CSP and only 24 blocked the payload.
- What would have caught it: Others check where code comes from. Reflectiz checks what it does, continuously, on live pages.
- The question to ask: Would you know within hours if a trusted script started doing something new?
Your website runs code you didn’t write
Researchers revealed this week that attackers served malicious JavaScript to visitors of some of the world’s most trusted websites. Here is how the numbers fit together:
| Measure | Count | What it means |
|---|---|---|
| Optimizely scripts analyzed | 1,611 | Optimizely scripts checked for injected code |
| Scripts with malicious code | 188 | Found in the sample |
| Organizations affected | 178 | Some organizations had more than one script |
| Affected hosts with CSP reviewed | 256 | Used for the CSP findings below |
The affected organizations include Zoom, CNN, Fox News, Salesforce, Equifax, GitLab, IKEA, HSBC, the BBC, Air France-KLM, Ledger, and Peacock. Banking and finance was the hardest-hit sector, with 32 organizations. The researchers believe the real total is higher.
None of these organizations had their own servers breached. The attacker added a small loader to the custom “Project JavaScript” field of Optimizely customer projects and left the rest of each script untouched. The poisoned file was still served from cdn.optimizely.com, with Optimizely’s valid certificate, from a domain every affected site already trusted.
Hudson Rock also traced an earlier wave, starting on November 13, through three other third-party services: Kissmetrics, StorifyMe, and minute-ly.
Optimizely has since said an attacker exploited a vulnerability in its Experimentation product. A spokesperson told Cointelegraph it was in the account signup flow. The company says it fixed the flaw, removed the code, and secured affected accounts. It has not said how the flaw worked or how many projects were affected.
Get a free security scan to see if you’re affected
Get my free scanWhat the malicious code did
The injected code was a multi-purpose toolkit:
- Crypto address swapping. It continuously scanned pages and the clipboard for cryptocurrency wallet addresses across eight chains and replaced them with addresses the attacker controlled.
- Card skimming. It hooked form submissions and outgoing fetch/XHR requests, validated card numbers, expiry dates, and CVVs, then sent them to an attacker endpoint.
- Data collection. Under certain conditions, it collected the page URL, any cookies readable by JavaScript, and a rendered screenshot of the page.
- iPhone targeting. When it detected an iPhone, iPad, or iPod, it inserted references that routed the device to exploit-kit infrastructure, with routing chosen by iOS version. The researchers stress that their scans show what the router served, not that any iPhone was compromised.
The code was also selective. The address swapper only acted on valid wallet addresses that appeared near words like “wallet,” “deposit,” or “send.” The skimmer could not read card fields inside hosted payment iframes such as Stripe or Adyen.
The attacker also built in resilience:
- There were three versions of the loader: a plain script tag, a version hidden with Base64 encoding, and one that carried a complete copy of the payload and ran it with eval if the attacker’s domain was blocked.
- Blocking the attacker’s domain did not remove the threat. On one HSBC site, the backup copy ran even though the main payload file was blocked.
- The attacker rebuilt the payload 26 times in a single day.
- The minute-ly loader deleted its own script elements after three seconds, so anyone inspecting the page afterward might find nothing.
Timeline (all times UTC, November 16)
| Time | Event |
|---|---|
| 04:21 | First injection appears in the BBC’s script. The attacker’s main domain was registered afterward |
| 13:43 | Card skimmer added |
| Shortly after 17:00 | iPhone exploit stage added |
| About 20:40 | Mass cleanup begins |
| 21:52 | One infected script remains. Smartsheet’s script was re-infected after being cleaned |
Report URI’s tally of wallet transfers linked to the attack was about $7,000 as of November 17. Bitquery noted the figure included a Bitcoin transfer linked to the attacker’s own swap (EconoTimes). Nobody yet knows how many card numbers or cookies were taken.
Why traditional defenses missed it
This incident sits in a blind spot that most security stacks share:
- WAFs and server-side tools watch traffic to and from your servers. This code never touched them. It traveled from the vendor’s CDN straight into the visitor’s browser.
- Code reviews and SAST only cover code you write and deploy. Optimizely project code and third-party widgets change outside your release process, often configured by marketing teams.
- Domain allow-lists, including a Content Security Policy, did not help, because the malicious code arrived from an already-trusted domain.
- Point-in-time checks were undermined by the self-deleting loader and by the iPhone-only branch, which a desktop scan would never trigger.
The CSP data is blunt. Of 256 affected hosts whose Content Security Policies were reviewed, 68 had no CSP at all, 50 had one that let both the payload and the data theft through, and only 24 blocked the payload outright. The breakdown we used does not itemize the other 114.
Cookie consent tools offered no protection either. As researcher Amirul Cyber points out, a consent banner decides whether a tag runs, not whether the tag is clean.
What was needed was continuous visibility into what third-party code actually does when it runs in a real browser.
How Reflectiz could have helped
This is the kind of problem the Reflectiz web exposure management platform was built for. It monitors every first-, third-, and fourth-party script, pixel, and tool that runs on a live website.
One limit first. In this attack, a backup copy of the payload sat inside the trusted Optimizely file, so blocking the attacker’s domain alone would not have been enough. The value here is early, continuous detection. Here is how the approach maps onto the attack.
- Spot the behavioral change, not just the source. Reflectiz monitors how each script behaves on a live site and alerts when that behavior changes. An Optimizely snippet that starts reading the clipboard, hooking payment forms, rendering the page with html2canvas, and posting data to card.php and hit.php on an unknown domain would be flagged. Detection based on behavior does not depend on which domain served the code, so the trusted Optimizely CDN does not hide it. With the payload rebuilt 26 times in one day, file hashes and known signatures keep falling behind.
- Detect new and unknown destinations. The live payload was fetched from domains such as 1688360[.]cc and webshell[.]lol, alongside a set of throwaway .icu domains. Reflectiz maps where each third party sends data, so new outbound connections to unvetted infrastructure would trigger an alert.
- Flag access to sensitive data. Reflectiz analyzes which third parties access personally identifiable information and payment data. That gives teams the evidence they need to help meet PCI DSS 4.0.1 requirements 6.4.3 and 11.6.1.
- Watch execution on real pages. Reflectiz runs remote sandboxed browsers that simulate real user activity and observe network requests and script activity as they happen. That matters twice here. The minute-ly loader erased its own traces after three seconds, and the address swapper only acted near payment wording, so it could stay quiet on test or staging pages. Monitoring what actually executes on live production pages, including checkout and account pages, picks up that kind of conditional behavior.
- Add no new code to your supply chain. Every script embedded in your site is a potential entry point, including the scripts of security tools. Reflectiz monitoring runs remotely, with no agent or JavaScript added to your pages. The only optional on-site component is a blocking script you enable when you choose to block something.
- Respond fast and with evidence. Once a malicious script is confirmed, on-demand blocking can stop a malicious third-party domain from executing without a code deployment. Affected sites served the code for most of a day before the mass cleanup, and at least one script was re-infected after being cleaned. Continuous monitoring gives teams the evidence to pull compromised code quickly, and tells them if it comes back.
Watch: how the Optimizely attack worked and how Security Hub would help
In this video, Or Sahar, a Reflectiz security researcher, explains how the Optimizely attack worked and how Reflectiz Security Hub would help. It covers what happened on November 16, how Security Hub watches what every script does, and four simulated scenarios that show how it responds. The test sites and attacks in the video are simulated, and nothing reaches the internet.
| Scenario | How Security Hub responds |
|---|---|
| 1. Known attacker | The script contacts an address already tied to attackers. Security Hub flags it as a known attacker |
| 2. Hidden address | The attacker scrambles the address to hide it. Security Hub sees the result once the browser unscrambles it and flags it |
| 3. Brand-new attacker | No address is known as bad. Security Hub flags all 4 suspicious actions by behavior alone |
| 4. Normal script | A normal script runs with no alarms and no false positives |
Others match scripts against lists of known bad addresses. Reflectiz also watches what trusted scripts actually do, so it catches an attacker nobody has seen before.
Lessons for every security team
- Treat third-party scripts as part of your attack surface. If your marketing team can publish JavaScript to your production site through a SaaS console, that console is effectively a deployment pipeline. Lock it down with strong authentication and audit its change history. See web supply chain risks and tag manager security.
- Monitor behavior, not just inventory. Knowing that Optimizely is on your site is not enough. You need to know when it starts doing something new.
- Test like your visitors. Attacks increasingly target specific devices, operating systems, or regions. Monitoring should cover the range of devices and browsers your real audience uses.
- Prioritize sensitive pages. Payment, login, and account pages should carry the fewest third-party scripts and get the closest scrutiny. See web skimming and Magecart.
- Plan your response in advance. Know how you will preserve evidence, remove injected code, invalidate exposed sessions, and confirm what visitors are actually receiving.
The bottom line
Zoom, CNN, and the other affected organizations did nothing unusual. They used a popular, reputable tool the way thousands of other websites do. That is why client-side supply chain attacks are so dangerous.
Others check where code comes from. Reflectiz checks what it does.
On November 16, attackers had roughly 17 hours on some of the world’s biggest websites, rebuilding their code as they went. The question for every security team is simple: would you have known?
Get a free security scan to see if you’re affected
Get my free scanSources
- Report URI: World’s Largest Brands Infected With Malware Via Optimizely
- BleepingComputer: Optimizely supply chain attack infects major brands’ sites
- Cointelegraph via TradingView: Hackers inject credit card, crypto-stealing malware into 178 major websites
- iTWire: Optimizely says it has fixed flaw used to inject malicious scripts
- EconoTimes: Optimizely Flaw Put Malicious Code on Sites Linked to 178 Organizations
- Hudson Rock: Poisoned Scripts on BBC, Zoom and Other Major Websites
- Amirul Cyber: OPTIMJACK
- The Hacker News
FAQs
What happened in the Optimizely attack?
On November 16, 2026, attackers added malicious JavaScript to Optimizely-hosted scripts. Visitors to 178 organizations received crypto address swappers, card skimmers, and iPhone exploit-kit routing from a trusted Optimizely domain. Optimizely says it has fixed the flaw and removed the code.
Which organizations were affected?
Report URI named Zoom, the BBC, CNN, Salesforce, GitLab, IKEA, HSBC, Equifax, Air France-KLM, Ledger, and Peacock. Other reports also list Fox News. Banking and finance was the hardest-hit sector, with 32 organizations.
Does CSP stop this kind of attack?
Not on its own. The code came from a domain every site already trusted, so allow-lists did not block it. Of 256 affected hosts reviewed, 68 had no CSP, 50 had one that let both the payload and data theft through, and 24 blocked the payload.
Why did WAFs, SAST, and consent banners miss it?
WAFs watch server traffic, and this code went from the vendor’s CDN straight to the visitor’s browser. SAST covers code you deploy, and this code changed outside your release process. A consent banner decides whether a tag runs, not whether it is clean.
How do you detect third-party script attacks?
Monitor what scripts do, not just where they come from. Track behavior changes, new outbound destinations, and access to sensitive data on live pages in real browsers. Reflectiz does this remotely, with no agent or JavaScript added to your pages.
How does this relate to PCI DSS 6.4.3 and 11.6.1?
Requirement 6.4.3 covers managing payment page scripts. Requirement 11.6.1 covers detecting unauthorized changes to payment pages. This attack changed scripts on pages that handle card data, which is the scenario both requirements address.
Subscribe to our newsletter
Stay updated with the latest news, articles, and insights from Reflectiz.
Related Articles
AI Has Changed The Web.
Are You Ready for What’s Next?
Third-party code shifts by the hour. Supply-chain compromises strike without warning. AI-driven web attacks now evolve faster than traditional security can ever keep up.
Reflectiz delivers the continuous, real-time visibility needed to expose the risks traditional tools miss entirely.
Zero code changes. Zero access to your data. Ultimate peace of mind.