Optimizely Experimentation Platform Hijacked, 178 Organizations Exposed

Original title: Optimjack from the Outside: The Hijacked Script Was on Our Radar
78AI Score

Attackers exploited a vulnerability in Optimizely's Experimentation platform to inject malicious JavaScript served from the vendor's own CDN, reaching visitors of 178 organizations including global banks, newsrooms, airlines and a hardware-wallet maker. Tracked as OPTIMJACK, the payload swapped crypto wallet addresses, stole payment-card data and cookies, and pushed exploit kits to iPhones. The incident highlights third-party experimentation scripts as a systemic supply-chain trust anchor risk.

Full Report

Contents9 sections

All figures are aggregate and anonymized, drawn from Fortirix’s own external monitoring data. The footprint below reflects organizations observed loading Optimizely’s experimentation script; the live re-check was run on November 18, 2026. Every figure is a count of externally observed scripts, not a vulnerability verdict. See Methodology.


On November 16, 2026, attackers exploited a vulnerability in Optimizely’s Experimentation platform and used it to inject malicious JavaScript into customer projects. The payload was served from Optimizely’s own CDN, alongside the legitimate code, so it carried the trust of a vendor every target had deliberately allowlisted. By the time it was caught — the campaign now tracked as OPTIMJACK — it had reached the visitors of 178 organizations: global banks and a credit bureau, major newsrooms, airlines, streaming services, a hardware-wallet maker, household retailers, and some of the best-known names in SaaS.

The injected code was a Swiss-army skimmer: it swapped cryptocurrency wallet addresses, stole payment-card details, grabbed cookies and screenshots, and pushed the Coruna and DarkSword exploit kits to iPhone and iPad visitors. Optimizely has since removed the injected code, revoked tokens, reset affected accounts, and notified customers.

This week also brought Java4Shell — a JVM Base64 flaw (CVE-2026-114938) that a passive external engine fundamentally can’t see: the bug lives in the runtime, and nothing on the wire reveals it. OPTIMJACK is its mirror image. It’s a client-side supply-chain attack, and the compromised asset is a <script> tag on the public homepage — precisely the attack surface an external engine is built to watch. And we already were.

Why this attack is externally visible when Java4Shell wasn’t

The entire mechanism of OPTIMJACK lives where anyone with a browser can see it. The victim’s page loads a script from cdn.optimizely.com; the attacker changed what that script does. There’s no server-side runtime to inspect, no patch level hidden behind a login — the exposure is literally a URL in the page source.

That’s the defining property of modern web supply-chain attacks (Magecart, Polyfill.io, and now OPTIMJACK): the risk is third-party JavaScript you invited onto your most-trusted pages, and it is observable from the outside by anyone who bothers to record what scripts a site loads. We bother.

What we saw — the dependency behind the incident

A public list names 178 identified infected organizations — the researcher Scott Helme catalogued them by sector, with domains. Worth stressing: that 178 is itself a floor. It’s what analysts managed to pin down from the malicious infrastructure and telemetry, not a sworn-complete census of everyone whose snippet was touched. Different responders counted very differently — one incident-response team could directly verify only a handful of sites; the catalogued figure reached 178 — which tells you plainly that no single list is the whole picture. So this isn’t a story about victims nobody named — it’s a story about the dependency underneath them, and how much larger the exposed population is than any one incident list. That’s what a passive external engine is uniquely placed to map.

Our AI-footprint detector records the third-party and experimentation scripts a site loads, by script source. Across our corpus it flags 52 organizations loading Optimizely’s experimentation snippet — the exact cdn.optimizely.com/js/<projectID>.js include OPTIMJACK rode. The evidence is the raw script URL itself:

TEXT
https://cdn.optimizely.com/js/<projectID>.js

Read that number precisely. 52 is not 52 victims, and it is not 52 vulnerable or exploitable sites. It’s 52 organizations that embed the vendor’s script — the dependency a supply-chain attack rides. Whether any given one was actually injected is a separate question, and whether it’s still serving anything malicious is a third — we checked both, directly, below.

Line those 52 up against the public victim list and two things fall out:

  • Five of the 52 are on the infected-178 list — spanning finance, media, and SaaS. We’d flagged them as Optimizely users from the outside, as routine footprint, before the breach was disclosed. That’s ground-truth validation: what we observe passively maps to confirmed real-world exposure.
  • The other ~47 are not on the identified-victim list. They load the same Optimizely script; whether their specific project was injected and simply never identified, or never touched at all, isn’t something an external view can settle. What is certain is the dependency. These span financial services, telecom, healthcare, retail, media, and enterprise SaaS.

That second group is the real point. The 178 is a snapshot of one attack. The population carrying the dependency — everyone who embeds the vendor script that got hijacked — is far larger, and it’s exactly who the next Optimizely-class compromise would ride. An incident report names the casualties; external footprinting maps the exposure that produced them.

The honest part: 52 is a floor, and a low one

We’d rather undersell this number than oversell it, because the detector behind it is new. Our AI-footprint observer has only been recording since June 2026, in shadow mode, and so far it has run on roughly 9% of our scans. The 52 organizations are what surfaced from that sliver — the real figure, at full coverage, is multiples higher.

The publicly-named victims make the coverage gap concrete rather than abstract. Several of them sit in our corpus but outside the detector’s short window: they were last scanned in early 2026, before the footprint observer existed, so it never looked. A couple more we happened to scan on the incident days themselves — during and after Optimizely’s cleanup — by which point the snippet had already been pulled from the page we fetched. The named victims we did catch were simply the ones scanned in the detector’s brief lifetime, days before disclosure. None of that is a detection weakness; it’s a five-month-old keyhole.

Two caveats we’ll state plainly rather than bury:

  • Loading Optimizely is not the same as being infected. The identified injected set was 178 organizations — itself a floor, not a proven ceiling. Our 52 is the dependency surface — not a victim count. Five of our 52 are confirmed on the identified list; for the rest, “uses Optimizely” is the finding, not “was compromised.”
  • “We didn’t detect Optimizely on your site” is emphatically not “you’re clear.” The authoritative answer to “were we served OPTIMJACK” is Optimizely’s own affected-customer notification and your own tag inventory — never an external scan, ours included.

We re-checked: the cleanup held

A footprint is only half the story; the other half is current state. So we did what an external monitor should: for all 52 organizations, we took the live Optimizely scripts they load — 60 distinct script URLs — and fetched every one, today, directly from cdn.optimizely.com.

All 60 returned HTTP 200, and not one contained the OPTIMJACK payload. We checked for the campaign’s published indicators (the 1688360.cc loader, the .icu command-and-control hosts, the webshell.lol reference) and then went further — extracting every external domain each script references, hunting for any unlisted exfiltration endpoint or obfuscation the public IOC list might have missed. There was none. The external references were all ordinary: Optimizely’s own data platform, the customers’ marketing stacks, standard content CDNs.

So the scripts are still there — these organizations still run Optimizely, business as usual — but the malicious code is gone from all of them. This is a point-in-time read, and we’ll label it as one: a clean fetch today isn’t a root-cause sign-off, and other responders rightly caution that a single clean window proves nothing universal. But across all 60 scripts, on the day we looked, the payload was gone — Optimizely’s remediation held where we could see it, confirmed from the outside, script by script, with no special access. That is the whole loop a client-side supply-chain monitor should run continuously: see who loads the vendor script, fetch the script the page references, and inspect what it actually contains. Pointed at these 60 scripts on November 16, it would have caught OPTIMJACK while it was live — not confirmed the cleanup after.

What OPTIMJACK should change about how you watch your own pages

The uncomfortable lesson is that the defenses most teams reach for didn’t help here:

  • CSP allowlisting didn’t save anyone. Every victim had cdn.optimizely.com in their script-src allowlist — that’s how the vendor works. The malicious code came from the allowlisted, trusted origin. An allowlist stops unknown origins; it does nothing when a trusted one turns hostile.
  • Subresource Integrity (SRI) couldn’t apply. Experimentation snippets change constantly by design, so you can’t pin them to a hash. The very property that makes a script useful for A/B testing makes it unpinnable.

So the real defenses are inventory and behavior, not allowlists and hashes:

  • Inventory every third-party script on your sensitive pages — checkout, login, account. You cannot defend a supply chain you haven’t enumerated.
  • Minimize third-party JavaScript on money-and-credential pages. An experimentation or analytics tag on a payment form is a standing supply-chain risk, OPTIMJACK or not.
  • Watch for behavioral change, not just content change — new outbound destinations, new form hooks, new DOM listeners appearing in a vendor script.
  • Treat vendor-CDN trust as a dependency, not a given. The blast radius of any script you embed is the union of your security and that vendor’s.
  • When a vendor discloses, act on their notification first. Optimizely ended sessions, revoked tokens, and reset affected accounts — if you’re notified, rotate anything that script could have touched (session cookies, tokens) regardless of whether you think you were impacted.

The meta-point

Java4Shell and OPTIMJACK landed the same week and bracket exactly what external attack-surface management can and can’t do. The JVM flaw is real and serious, and from the outside it’s unconfirmable — the deciding facts aren’t on the wire. The Optimizely compromise is also real and serious, and from the outside it’s directly observable — the compromised asset is the wire. Honest external security is knowing which is which, and saying so: we can’t tell you your JDK patch level, and we can tell you which of your pages were loading the script that turned into a card skimmer.

For OPTIMJACK, the signal was sitting in plain sight on 178 homepages. The only question was whether anyone was writing it down.

Methodology

  • How we detect Optimizely. Our AI-footprint observer, running in shadow mode since June 2026, records the third-party scripts a page loads by their script_src. An Optimizely observation means a page we fetched included a cdn.optimizely.com/js/<projectID>.js (or equivalent) tag. It has run on roughly 9% of our scans to date, so the 52-organization figure is a floor, not a census.
  • What the counts mean. “52 organizations” counts distinct root domains observed loading an Optimizely script — the dependency surface. It is not a count of victims or of vulnerable sites. Five of the 52 also appear on the publicly catalogued list of injected organizations; that overlap is validation, not the measure itself.
  • The live re-check. On November 18, 2026 we fetched each distinct Optimizely script URL our footprint had recorded (60 in total) directly from cdn.optimizely.com, and scanned the returned content for the campaign’s published indicators and for any other external domain referenced. This is a point-in-time observation of static script content — not a dynamic, rendered, or authenticated test.
  • Anonymization. We name no organizations from our own detection. Named victims referenced in aggregate come from public reporting (see Sources).

Sources

Fortirix is a passive external attack-surface engine. Every figure here is a count of scripts we observed on pages we fetched — a floor on exposure, never a vulnerability verdict.

See your own external exposure

Fortirix maps your internet-facing attack surface the way an attacker's first pass would — passively, from the outside in. No agents, no credentials.

Request a scan