
Optimizely Supply Chain Attack: Malicious Scripts Reached Visitors of 178 Organizations
On November 16th, 2026, an attacker wrote malicious JavaScript into customer projects on Optimizely Web Experimentation.
November 17, 2026 - Blog

On November 16th, 2026, an attacker wrote malicious JavaScript into customer projects on Optimizely Web Experimentation. For most of that day, visitors to websites run by at least 178 organizations loaded code that swapped cryptocurrency wallet addresses, skimmed payment card data, stole readable cookies and page screenshots, and tried to push iPhones and iPads toward known iOS exploit kits.
None of those organizations had to be breached themselves. The code arrived inside a script they had already chosen to trust.
That makes this one of the clearest recent examples of third-party JavaScript risk. Mature internal security programs did not stop it, because the change never touched their own code, servers or repositories.
Report URI, the client-side monitoring company run by security researcher Scott Helme, found the injected code while monitoring third-party JavaScript. It identified malicious code in 188 of the 1,611 Optimizely snippets it checked. Those 188 snippets belong to 178 organizations, since some organizations run more than one Optimizely project. Report URI says the real number is likely higher because it could only check the snippets it found in time.
Affected organizations named in published research include CNN, the BBC, Fox News, Zoom, Salesforce, GitLab, IKEA, HSBC, Equifax, Air France-KLM, Ledger, and Peacock.
Optimizely's own www.optimizely.com and login.optimizely.com served the code too. Report URI's sector breakdown counted 32 banking and finance organizations, 23 technology and SaaS companies, 20 retailers, 12 streaming services, 10 news and media outlets, and 9 airlines and travel companies, among others.
Key times (UTC, November 16th unless noted):
04:21:
Report URI sees the first injection, in the BBC's snippet.
05:23:
The payload domain, 1688360[.]cc, is registered.
08:10:
The first of 26 payload builds that day goes live.
13:03 to 13:05:
The attacker sweeps stolen stablecoins out of its wallets.
13:43:
The card skimmer is added to the payload.
About 20:40 to 21:10:
Mass cleanup. By 21:52, only one of the 188 snippets (TalkTalk's) still carries the code.
November 17, 01:02:
Optimizely confirms the incident on its status page.
StepSecurity puts the exposure window at about 16 hours for most affected sites. Hudson Rock has also reported that the same actor's loader appeared in scripts from other vendors, including Kissmetrics, StorifyMe and Minute Media, from November 13th.
Optimizely's status page says an unauthorized party exploited a vulnerability in Experimentation and used it to add malicious JavaScript to some customer projects. The company says it fixed the vulnerability, removed the injected code, revoked sessions and tokens for affected accounts, notified affected customers and added protections against unauthorized code delivery. In statements to the press, Optimizely placed the flaw in the Experimentation account signup flow.
Two big questions remain open. Optimizely has not said how many projects were modified, and it has not explained how a flaw in account signup gave an attacker write access to unrelated customers' projects.
Optimizely Web Experimentation lets companies run A/B tests and personalization on their sites. Each site loads a JavaScript snippet tied to its Optimizely project, and that snippet can run custom code configured in the Optimizely dashboard. Marketing and product teams use this to change page elements without touching the site's own codebase.
That convenience is also the exposure. A script loaded into a page runs with the page's privileges. It can read and change the page, watch form input and make network requests, within the limits of the browser's same-origin rules.
The attacker wrote a loader into each affected project's Project JavaScript field, which runs on every page where the snippet loads. The rest of each snippet was unchanged. It was still served from cdn.optimizely.com with Optimizely's certificate, so nothing about the host looked wrong.
This was not CDN cache poisoning. Optimizely's CDN served exactly what the projects contained. Customers who serve the snippet from their own domain were hit as well, because the content still comes from the same Optimizely project. Report URI named opt.scheels.com and www.vodafone.com.au as examples. Cookie consent tools did not help either. On GitLab, the consent manager itself loaded the Optimizely bundle, which then loaded the attacker's script.
Report URI found three loader variants:
A plain script tag pointing to 1688360[.]cc/track.js.
The same URL hidden in base64 and decoded with
atob()
, which defeats a simple text search for the domain.
A full inline copy of the payload, run through
eval
, as a fallback if the attacker's domain was blocked.
The third variant matters. Blocking the attacker's domain was not enough on its own.
The payload was a single file of roughly 30 KB. The attacker rebuilt it 26 times on November 16th and served it with a 15-second cache lifetime, so changes reached visitors almost immediately. It had four parts.
The clipper looked for wallet addresses on Bitcoin, Ethereum and other EVM chains, TRON, Solana, TON, Litecoin, Bitcoin Cash and Dogecoin. It only swapped addresses that passed the chain's checksum and sat near payment words such as "wallet," "deposit" or "send."
It hooked far more than visible text. It rewrote addresses in form fields, link and image attributes, copy events, the clipboard API, navigator.share, and the URLs and bodies of outgoing fetch and XHR requests. So copying an address from an affected page, then pasting it into a wallet app, could send funds to the attacker. This part ran for every visitor.
Report URI traced about $7,040 to the attacker's wallets by 19:25 UTC on November 16, most of it (about $5,380) in Bitcoin. Treat that as a floor rather than a clean count of victim losses. At least one of the attacker's TRON wallets had been in use since March 2026, so not every incoming transaction can be tied to this campaign, and StepSecurity observed new inflows on November 17. Totals reported elsewhere vary.
The skimmer was added at 13:43 UTC, roughly nine hours after the first injection, so card exposure was shorter than the clipper's. It wrapped fetch and XHR and listened for form submissions. When it found a card number that passed a Luhn check and matched a known card brand, plus a valid expiry date and CVV, it sent them with the page URL to 1688360[.]cc/card.php. It did not collect cardholder names or billing addresses. It also kept captured cards in the browser's sessionStorage under keys starting with cc_.
The skimmer had a hard limit. It could not read card fields inside cross-origin hosted payment iframes, the kind offered by providers such as Stripe and Adyen. The browser's same-origin policy keeps a script on the parent page out of those frames.
So a site loading the malicious script does not mean every customer's card was stolen. Exposure depends on whether the site collected card data in its own form fields, and whether a customer paid between 13:43 UTC and cleanup.
aran after the clipper swapped an address in a visible element, and at most once per page load. It then loaded html2canvas, captured the visible page as a JPEG and sent it to 1688360[.]cc/hit.php along with the page URL, up to 8,000 characters of document.cookie and up to 20 of the original wallet addresses.
Cookies marked HttpOnly were out of reach. Session cookies without that flag were not. A stolen session cookie can let an attacker into an authenticated account without a password, depending on session lifetime and whether the site re-checks the device or asks for reauthentication.
On iPhones, iPads and iPods, the script loaded boot.js from attacker-controlled .icu domains, checked the iOS version and loaded an exploit chain in a hidden iframe:
iOS 13 to 17:
Coruna
iOS 18.x:
DarkSword
iOS 26:
a separate chain that only fingerprinted the device when Report URI examined it
On iOS 18.6 or earlier, affected pages reloaded every 60 seconds to retry. The kit's own comments mark iOS 18.7.3 and later, and iOS 26.3 and later, as patched.
Coruna and DarkSword are not new. Google's Threat Intelligence Group, iVerify and Lookout documented both in March 2026, first in state-linked espionage and later in criminal use.
Delivery is documented. A successful compromise of a real device through this campaign has not been demonstrated. Whether any device was compromised depends on its iOS version and patch level.
Modern sites load JavaScript from analytics providers, ad networks, consent managers, support widgets, experimentation tools and payment services. Each one runs inside your page. When one of those vendors is compromised, every customer site that loads its code becomes a delivery channel.
Vendor reviews at procurement don't cover this. A vendor can pass a security questionnaire in March and serve malware in November. Contracts and certifications describe the vendor's intentions. Technical monitoring tells you what its code is actually doing in your customers' browsers.
It also changes what "breach" means. Many of the 178 organizations may find no unauthorized access to their networks or databases, yet their customers still had cards skimmed or wallet addresses swapped on their pages. That carries financial, legal and reputational consequences, and depending on the data involved and the jurisdiction, it may trigger breach notification obligations.
If your site handles payments, authenticated sessions or sensitive personal data, third-party script security belongs in your data protection program.
This incident gives unusually concrete evidence about which controls helped.
Report URI reviewed the Content Security Policies of affected organizations. Only about 15% (24 organizations) had a policy that blocked the payload. 68 had no CSP at all. 50 had a CSP that allowed both the payload and the data theft. For 17 more, the payload ran but a connect-src restriction blocked data from leaving.
What that tells you:
Allowlisting cdn.optimizely.com did nothing.
The malicious code came from that trusted host.
A tight
script-src
host allowlist worked.
Listing only the script hosts a site needs blocked the request to 1688360[.]cc.
'strict-dynamic'
let the payload through.
It tells the browser to trust any script that a trusted script inserts. Nonce-based policies with
strict-dynamic
are a common recommendation, but here the trusted Optimizely snippet inserted the attacker's loader, so trust passed straight to it. Nonces and hashes control which scripts load first. They don't control what a trusted script loads next.
'unsafe-eval'
let the inline fallback run.
At HSBC, the request for track.js was blocked, but the inline copy still executed.
connect-src
limited the damage but didn't stop all of it.
It blocked card, cookie and screenshot exfiltration. It did not stop address swapping, which happens entirely inside the page.
Test CSP changes in report-only mode before enforcing them, and keep violation reporting on. Those reports are an early warning when a trusted script starts calling unfamiliar domains.
Subresource Integrity (SRI) makes the browser refuse a script whose content doesn't match an expected hash. It works well for static libraries. It is a poor fit for Optimizely and similar tools, because the snippet changes every time someone publishes an experiment. A pinned hash would break legitimate updates. Where SRI isn't practical, monitoring has to carry more of the load.
Hosted payment fields in cross-origin iframes held up. The skimmer could not read them. Sites that kept card entry inside a provider's iframe, and kept unneeded third-party tags off checkout pages, limited their card exposure regardless of what the Optimizely script did.
Report URI caught this by watching what third-party scripts actually did in browsers. Code review and repository scanning would have seen nothing, because the change lived in a field inside a vendor dashboard. Server logs would show normal traffic.
Useful client-side signals include:
Changes to third-party script content compared with a known-good baseline
CSP violation reports naming new domains
Browser requests to destinations you've never seen before
Changes to payment forms or checkout behavior
Scripts touching cookies, the clipboard API or form fields they have no reason to touch
You can't prevent every vendor compromise. You can make one far less damaging.
Keep an inventory of every external script. For each one, know what business function it serves, which pages load it, what it can read or change (including forms), who controls its delivery and whether you still need it. Remove what you don't need. Every script you drop is one less vendor that can serve code to your customers.
Limit where third-party scripts run. An experimentation tool rarely needs to run on checkout, login or account pages. Load each script only where it's required.
Lock down vendor dashboards. Anything that can edit code a vendor serves to your site is effectively production access. Enforce SSO and MFA, review users and API tokens regularly, and find out whether the vendor offers change approval or alerting for custom code.
Write a CSP that assumes a trusted vendor will turn hostile. Use a specific script-src allowlist, restrict connect-src, avoid 'unsafe-eval', and think carefully before relying on 'strict-dynamic' for pages that load third-party tools.
Test it. Penetration testing should cover more than your own application logic. A good assessment asks what a compromised dependency could reach on your pages: payment fields, session cookies, account actions. Then validate that your fixes actually work. Removing a script or deploying a CSP only helps if no other execution path remains.
Audit every Optimizely Web project.
Read the Project JavaScript field and experiment code in each one. Searching for
1688360
and
atob(
is a start, but read the code rather than relying on a string search. Include snippets you serve from your own domain.
Review account access.
List users and API tokens, remove anything you don't recognize and rotate credentials. Ask Optimizely which of your projects changed, when and through which account.
Search your logs.
Look in DNS, proxy and CSP report logs for the indicators below, starting from 04:00 UTC on November 16.
Invalidate sessions.
If your session cookies aren't HttpOnly, force re-login for users who visited affected pages during the exposure window.
Assess card exposure.
If you collect card numbers in your own form fields rather than a hosted iframe, treat cards entered between 13:43 UTC and your cleanup time as compromised and check your notification obligations.
Tell your customers what to do.
Verify wallet addresses on the wallet or hardware-wallet screen before sending, watch card statements, and update iPhones and iPads to iOS 18.7.3 or later, or 26.3 or later.
Defanged indicators from Report URI and StepSecurity:
Payload and exfiltration:
1688360[.]cc (paths /track.js, /card.php, /hit.php, /html2canvas.min.js)
Injector (reported by Report URI):
webshell[.]lol
iOS stage domains:
l7bcsnwc7nzr3uo[.]icu, 5vobauua3ojpklx[.]icu, p55abnw2pnsz0bo[.]icu, eil786npto9u5bq[.]icu, 1y69gy2mdzaltz1[.]icu, gm38duxoihbmy5o[.]icu
iOS stage paths:
/boot.js, /JIUJIU888/weifile.html, /JIUJIU888/index.js
Browser artifacts:
window._k7
,
window._cc
,
window._qxc
,
window._shot
, sessionStorage keys beginning
cc_
The payload changed many times, so match on domains and behavior rather than a single file hash.
In the Optimizely supply chain attack, the attacker didn't need a separate vulnerability on each of 178 websites. One compromised shared service delivered the code to all of them.
Your security perimeter includes every script your pages execute. So run the scenario before it happens to you. If your analytics, experimentation or support vendor started serving malicious code tomorrow:
Would you detect the change, or would a researcher tell you?
Could that script read your payment fields or session cookies?
Would your CSP block its outbound connections?
Could you switch the integration off quickly without breaking critical pages?
If you can't answer those confidently, that's your testing plan.