November 17, 2026

Don’t unknowingly “optimize” your site for third-party supply chain attacks

November 17, 2026
Ivan Tsarynny
Ivan Tsarynny

Best practices for protecting your websites and mobile apps from attacks originating in Optimizely scripts.

Think about the last third-party script your team approved. Someone reviewed the vendor, someone signed the contract, and someone added the tag. In a lot of companies, that review is the last close look the script ever gets. From then on the vendor's code runs on your pages every day, and whoever controls the vendor's systems decides what it does.

On November 16, 2026, an attacker used that gap against 178 organizations. They added malicious JavaScript to customer projects in Optimizely Web Experimentation, a widely used A/B testing tool. The code sat inside each customer's own Optimizely snippet and came from Optimizely's own servers, so visitors' browsers loaded it as part of the site.

Independent researchers traced the code to the websites of 178 organizations. The list spans banks, news outlets, software companies, retailers and airlines. Optimizely has confirmed the breach and says it has fixed the flaw and removed the malicious code from customer projects.

Nothing changed in these companies' repositories, servers or deployments. So the question for your own team is a practical one: if a script you already approved started doing something new on your checkout page, how long would it take you to find out? For most security and compliance leads it's an uncomfortable question, because you're accountable for code your team didn't write, running on systems you can't inspect.

What happened on November 16

According to Optimizely, someone abused a security flaw in its Experimentation product to plant malicious JavaScript in a number of customer projects. The company has traced the flaw to its account signup process, but hasn't said how a problem at signup let the attacker edit projects belonging to other customers.

The attacker's foothold was a small loader script. It went into a setting called Project JavaScript, which lets each customer add custom code that runs wherever their Optimizely snippet loads. Everything else in the snippet stayed the same, and it was still delivered from Optimizely's network under Optimizely's certificate. Hosting the snippet on your own domain didn't help either: those copies are built from the same project, so they carried the loader too.

Researchers date the first injection to roughly 04:21 UTC on November 16. Most snippets were cleaned between about 20:40 and 21:10 UTC that evening, so the typical site served the malware for around 16 hours. The attacker kept working the whole time: researchers counted 26 versions of the payload that day, with wallets and features added as the day went on.

Of the 1,611 Optimizely snippets the researchers were able to examine, 188 were infected, spread across 178 organizations. They expect the true count to be higher. Financial services led the list with 32 affected organizations, ahead of technology and SaaS firms and then retailers.

The same operation may have reached beyond Optimizely. Hudson Rock and an independent researcher found tampered scripts from Kissmetrics, StorifyMe and minute-ly dating back to November 13. Those scripts ran on shared infrastructure and used similar loader code, but the researchers stop short of saying one attacker was responsible or that all four vendors were breached the same way.

What the code did to visitors

Everything ran from a single script of roughly 30 KB that did four things at once.

  • It watched for cryptocurrency wallet addresses that visitors copied or typed next to words like "deposit" or "send", and quietly replaced them with a valid address belonging to the attacker.
  • From the afternoon of November 16, it read card numbers, expiry dates and CVVs as shoppers entered them into checkout forms built into the site's own pages.
  • After a wallet swap, it captured a picture of the page and any cookies it could access, then sent both to the attacker.
  • On iPhones and iPads it loaded known iOS exploit kits, and on devices running older iOS versions it refreshed the page once a minute to keep trying.

The attacker's wallets collected roughly $7,000 in cryptocurrency before they were emptied on November 17. The card losses are harder to count, because nobody outside the affected companies can see how many cards were skimmed.

It came from a domain the companies already trusted. Every request went to Optimizely's own domain over a valid certificate. Any defense that grants trust based on where code is hosted waved it through, including a Content Security Policy with Optimizely on its allowlist.

The researchers reviewed the affected organizations' policies: roughly 15% would have stopped the attack. Sixty-eight organizations had no policy in place, and 50 had policies loose enough that the malware both ran and got the stolen data out.

The companies' own code never changed. Code reviews, repo scans and pen tests look at the software your developers write and ship. The malicious change lived inside a vendor's platform, so none of them had anything to flag.

The file changes all the time anyway. Teams launch and end experiments constantly, and each one produces a new version of the snippet. That rules out integrity checks tied to a fixed file hash, and to any check that only looks for change, the attacker's edit looked like one more experiment going live.

A consent banner decides when a script loads. On at least one affected site, the cookie consent tool was what loaded the Optimizely snippet. A consent tool answers one question: has this visitor agreed to this category of tracking? It doesn't inspect the code it switches on.

Hosted payment fields protect one field. The skimmer could not read card numbers typed into a payment provider's hosted fields inside a separate frame, and that protection held. The rest of the page had no such cover, and on it the same script swapped wallet addresses, read cookies and went after mobile visitors.

The approval gap

Most companies approve a vendor at one moment: a security review, a contract, a line in the tag manager. The vendor's script then runs on their pages every day after that, and its behavior can change at any time. The approval gap is the distance between what you checked back then and what the script does today.

This has happened before, and recently. In March 2026, AppsFlyer's JavaScript SDK was compromised and malicious code went out to the websites that loaded it, without those websites changing a line of their own code.

Polymarket has been hit the same way twice this year. In June, a compromised third-party vendor injected a malicious script into its front end that drained about $3 million from user wallets. On October 29, attackers hijacked the domain records of a website performance-monitoring vendor and served a malicious script on Polymarket's trading page, taking about $2.7 million from 726 wallets within about an hour.

The PHP2Shell vulnerabilities disclosed in October opened a second way in. An attacker who takes over a vulnerable PHP server can rewrite the pages and scripts it serves. If that server belongs to a script vendor, every site that loads the vendor's script starts delivering the attacker's code at the same time. Days later, Node2Shell (CVE-2026-111497) opened a similar path on servers running Node.js, through a flaw in its built-in Brotli decompression that can, in the worst case, let an attacker run code on the server.

A/B testing tools, analytics, chat widgets, tag managers and marketing pixels all work the same way. Each one comes from a vendor that can change code running next to your customers' card numbers, passwords and personal data.

Leave the gap open and the next breach plays out the same way: card numbers and wallet addresses leave your checkout page under your brand, and you hear about it from a researcher, a customer or your assessor instead of your own tools.

Your customers trust your checkout page. You should be able to see everything that runs on it.

Six checks to run immediately

  1. Audit every Optimizely Web project by hand. Go into the Project JavaScript setting of each project and look for anything your team can't account for. Save a copy for your incident records, then remove it. A text search of the delivered snippet isn't enough, because one version of the loader encoded the attacker's address in base64 and another embedded the whole payload. If you host the snippet on your own domain, audit that copy as well.
  2. Block the known indicators and look back. Put the attacker's domains on your DNS and proxy deny lists, and review logs from 04:00 UTC on November 16 onward. StepSecurity publishes the full indicator list.
  3. Lock down who can change your vendor scripts. Audit every user and API token on your Optimizely account, revoke anything you can't identify, and ask Optimizely for a record of which of your projects changed, at what time, and under which login.
  4. Use your CSP reports as evidence. If your Content Security Policy blocked calls to the attacker's domains, those reports and your other browser telemetry point to the exact pages that carried the loader.
  5. Bring in your payment, fraud and legal teams. If customers entered payment details or copied wallet addresses on an affected page during the window, decide the next steps with them now.
  6. Inventory the third-party scripts on your sensitive pages. For checkout, login and account pages, record which scripts load, where they come from, what data they can reach and who can change them. You'll need that list the next time a vendor is breached.

What your PCI DSS assessor will ask

PCI DSS 4.0.1 has two requirements written for this kind of attack. Requirement 6.4.3 asks you to authorize every script on your payment pages, confirm its integrity, and keep a written inventory with a business reason for each one. Requirement 11.6.1 asks for a way to alert your team to unauthorized changes to page content and HTTP headers as the customer's browser receives them, evaluated at least weekly or at the frequency your risk analysis sets.

A vendor-hosted script that changes on the vendor's side is the hard case for both. It comes from an approved domain with a valid certificate, and the change happens on systems you don't control. After an incident like this one, expect your assessor to ask what you did about it and to ask to see the evidence.

How Feroot helps you close the approval gap

We built Feroot for teams in exactly this position: responsible for checkout, login and account pages that load code from vendors they can't audit from the inside, and answerable to a PCI DSS assessor for all of it.

Feroot DXSecure watches what every first-, third- and fourth-party script does on your websites and mobile apps. Where a script comes from is not treated as proof that it is safe.

  • You always have a current inventory. AI agents find the pages across your web properties and catalog every script running on them: what loads, where it comes from and what data it can reach.
  • You find out when a trusted script starts behaving differently. DXSecure monitors third-party scripts for behavioral changes that signal compromise, such as new scripts, modified code, or a tag that suddenly starts reading payment fields.
  • Sensitive data stays on the page. When a script tries to read or send sensitive data outside your policy, DXSecure blocks it before the data leaves.
  • Your assessor gets evidence. PaymentGuard supports your program under PCI DSS 4.0.1 Requirements 6.4.3 and 11.6.1 with a current script inventory, authorization records, integrity checks that catch changes made upstream at the vendor, and change alerts.

Feroot cannot stop a vendor's own platform from being breached, and it does not replace your consent platform. It shows you what that vendor's code is doing on your pages today, and it blocks the code when it tries to take data outside your policy.

Your plan

  1. Get a free assessment of your checkout, login and account pages.
  2. See every script on those pages, where it comes from and what data it can reach.
  3. Turn on monitoring and blocking, so the next change to a vendor script is flagged and stopped before data leaves the page.

When the next vendor is breached, your team gets the alert, the data stays on the page, and the evidence is ready when your assessor asks for it.

See what every script on your checkout, login and account pages is doing right now, before the next vendor breach tells you. Get a Free Assessment

Not ready to talk to us yet? Scan your checkout page free and see every script running on it in under 3 minutes.

Sources

See what every script on your checkout, login and account pages is doing right now

Explore DXSecure