On this page
On 16 November 2026 an attacker added malicious JavaScript to customer projects in Optimizely Web Experimentation, a widely used A/B testing tool. For about 16 hours, visitors to affected sites loaded code that swapped cryptocurrency wallet addresses, skimmed card details typed into the site's own forms, and sent cookies and screenshots to the attacker. The code came from Optimizely's own CDN, so the browser trusted it.
If your website loads Optimizely Web, or any similar third-party tag that can run code you didn't write, this brief is for you. It covers what is known, how to check whether you were affected, what we tested in our lab, and what to change so the next tag compromise does less damage.
What happened
Optimizely Web works by loading a JavaScript "snippet" from cdn.optimizely.com/js/<project-id>.js (or from the customer's own domain) on every page. The snippet includes a field called Project JavaScript, which runs on every page load. It is meant for site-wide experiment code.
According to Report URI's analysis by Scott Helme, the attacker wrote a loader into that field in many customer projects. The CDN was not poisoned. It served exactly what the projects contained. The first injection was seen at 04:21 UTC on 16 November and mass clean-up happened between about 20:40 and 21:10 UTC. Helme reported all infected files clean by 23:11 UTC. During the day the payload was rebuilt 26 times, and a card skimmer was added at 13:43 UTC.
Optimizely's status page (update at 01:02 UTC on 17 November) says an unauthorised party "exploited a vulnerability in Experimentation" to add malicious JavaScript to some customer projects. It also says the company has fixed the vulnerability, removed the injected code, secured affected user accounts and added protections against unauthorised code delivery. ITPro and StepSecurity report the same statement.
The researchers describe four things the payload did:
- Wallet address swapping. It replaced valid BTC, ETH and EVM, TRON, Solana, TON, Litecoin, Bitcoin Cash and Dogecoin addresses in page text, forms, links, the clipboard and outgoing requests. It checked the address checksum first, so swapped addresses looked valid.
- Card skimming. It captured card number, expiry and CVV from the site's own forms and sent them to the attacker. Card fields inside a payment provider's hosted iframe were out of reach.
- Cookie and screenshot theft. After a swap, it sent the page URL, cookies readable by JavaScript and a screenshot of the page.
- iOS exploit loading. On iPhones and iPads it loaded further scripts that the researchers link to known iOS exploit kits. Whether any device was actually compromised has not been shown.
Who is affected
- Sites using Optimizely Web Experimentation (the client-side snippet), including those that serve the snippet from their own domain. Researchers checked 1,611 snippets and found 188 infected, across sectors including banking and finance (32 organisations in their list), technology and SaaS (23), retail (20) and crypto and trading (6). They expect the true number to be higher.
- Visitors to those sites on 16 November, roughly 04:00 to 21:00 UTC. In particular, anyone who copied or pasted a wallet address, typed card details into a non-iframe form, or browsed on an iPhone running iOS 18.6 or earlier.
- Product scope: Optimizely's status page lists the affected component as Web Experimentation (Snippet Delivery). It has not published a fuller product list, so confirm with them if you use other Optimizely products.
Even if you don't use Optimizely, the lesson applies to any third-party tag that can inject code. Researchers also report an earlier wave from 13 November that used other vendors' scripts, which has not been independently confirmed.
How to check your exposure
1. Review every project's custom code
In Optimizely, open each Web project and read Project JavaScript and the custom code in each experiment. Look for anything you didn't write. Don't search for the attacker's domain alone: researchers saw three loader variants, one a plain script tag, one hidden with base64 and atob(), and one an inline copy of the whole payload run with eval.
We wrote a small read-only checker for the snippet and for exported Project JavaScript. It looks for the published domains and file hashes, plus generic patterns that catch the hidden variants:
IOC_DOMAINS = ["1688360.cc", "webshell.lol", "linkforge.cc", "ios-hack.icu",
"5vobauua3ojpklx.icu", "eil786npto9u5bq.icu", ...] # full list in Report URI's post
PATTERNS = {
"atob() decoding": r"\batob\s*\(",
"eval / new Function": r"\beval\s*\(|new\s+Function\s*\(",
"dynamic <script> injection": r"createElement\(\s*['\"]script['\"]\s*\)",
"payload markers": r"window\.(_k7|__k7b|_cc|_qxc|_shot)\b",
"Function.prototype hook": r"Function\.prototype\.(call|apply)\s*=",
}
# Never executes the snippet: reads the bytes, hashes them, then matches text.
We tested it against two files from our lab: a clean vendor snippet and one where we had added the three loader shapes (pointing at a harmless lab host).
$ python3 check_snippet.py clean.js injected.js; echo "exit=$?"# clean.js sha256=52d5d0a248836706… 30 bytes[+] no indicators found# injected.js sha256=0a64245348521416… 467 bytes[!] MEDIUM: atob() decoding x1: review whether you wrote this[!] MEDIUM: eval / new Function x1: review whether you wrote this[!] MEDIUM: dynamic <script> injection x2: review whether you wrote thisexit=1The generic patterns are for your Project JavaScript and experiment code, which should be short and familiar. Run against the full Optimizely snippet they will also fire on the vendor's own code. There, rely on the domain and hash checks, and compare the snippet against a copy you saved before 16 November if you have one.
2. Check who can write to your Optimizely account
List users, API tokens and integrations. Remove anything unrecognised and rotate the rest. Optimizely says it ended sessions and revoked tokens on affected accounts. Ask them which of your projects were changed, when, and by which account.
3. Decide what data was in reach
If card fields on your site are your own form fields rather than a payment provider's iframe, treat cards entered on 16 November as potentially exposed and talk to your acquirer. Session tokens stored in cookies without the HttpOnly flag should be rotated.
Detection
DNS and proxy logs
Block the published domains and search back to at least 13 November. Match on the domain and its subdomains, not a substring. In our lab we generated a three-day DNS log of 5,004 queries from 10.0.0.x clients, with four planted IOC lookups and a decoy name, 1688360.cc.example.org, that contains an IOC as text but isn't one.
$ grep -c '1688360.cc' dns.csv619$ python3 hunt_dns.py dns.csv[!] HIGH: 10.0.0.17 resolved webshell.lol x1 first=2026-11-14T11:02:55Z last=2026-11-14T11:02:55Z[!] HIGH: 10.0.0.23 resolved 1688360.cc x2 first=2026-11-16T09:14:02Z last=2026-11-16T09:14:03Z[!] HIGH: 10.0.0.41 resolved eil786npto9u5bq.icu x1 first=2026-11-16T15:40:11Z last=2026-11-16T15:40:11Z# 3 client/domain pairsA hit from a staff device means someone browsed an affected site. It doesn't mean your own site was affected. Check whether that person entered card details, copied a wallet address, or uses an older iPhone.
CSP reports
If your site sends Content Security Policy violation reports, look for blocked script-src or connect-src requests on 16 November to hosts you don't recognise. That is how a policy turns a supplier compromise into an alert, even in report-only mode.
Mitigation: what a Content Security Policy actually stopped
Report URI's crawl found that only a minority of affected organisations had a policy that blocked the payload, and that some common CSP setups let it through. We wanted to see why, so we built a lab: a shop page at shop.example.com, a vendor snippet from cdn.example.com, and an attacker host. We injected the three loader shapes into the vendor snippet, then loaded the page in Chromium under six policies.
# CASE 2: injected snippet, no CSPGET attacker.example.net/track.jsPOST attacker.example.net/hit body='inline-fallback'POST attacker.example.net/hit body='from-track.js'# CASE 3: script-src 'self' http://cdn.example.com:8000; connect-src 'self'CSP-REPORT script-src-elem http://attacker.example.net:8000/track.js enforceCSP-REPORT script-src-elem http://attacker.example.net:8000/track2.js enforceCSP-REPORT script-src eval enforce# CASE 4: same plus 'unsafe-eval' (eval runs; connect-src stops the beacon)CSP-REPORT script-src-elem http://attacker.example.net:8000/track.js enforceCSP-REPORT connect-src http://attacker.example.net:8000/hit enforce# CASE 5: script-src 'nonce-lab123' 'strict-dynamic'GET attacker.example.net/track.jsGET attacker.example.net/track2.jsPOST attacker.example.net/hit body='from-track.js'# CASE 6: the case 3 policy as Report-Only (everything reported, nothing blocked)GET attacker.example.net/track.jsPOST attacker.example.net/hit body='inline-fallback'CSP-REPORT connect-src http://attacker.example.net:8000/hit reportWhat this shows:
- A host allowlist in
script-srcblocked both external loaders and theevalfallback. Nothing reached the attacker. 'unsafe-eval'let the inline copy run.connect-srcstill stopped the data leaving, but an address swap happens inside the page and needs no network request. That matches Report URI's finding that some sites blocked exfiltration but not swapping.'strict-dynamic'trusts any script loaded by a trusted script. The vendor snippet carried the nonce, so everything it loaded was trusted too. This mode is good against cross-site scripting in your own code, but not against a compromised supplier.- Report-Only blocked nothing but reported everything. It costs nothing to deploy today and would have flagged this attack within minutes.
Subresource Integrity (SRI) hashes don't help with tags like this, because the vendor changes the file whenever you edit an experiment. The other durable fixes are architectural. Keep payment fields in your provider's hosted iframe, set HttpOnly on session cookies, and keep third-party tags off checkout and wallet pages unless they are essential. In a web application penetration test we review each page's third-party scripts and CSP alongside the server-side findings. Our post on ten security basics covers the wider hygiene around it.
What we know and what is unconfirmed
Status as of 18 November 2026, based on sources fetched that morning (UTC).
Confirmed by Optimizely: an unauthorised party exploited a vulnerability in Experimentation and added JavaScript to some customer projects. The vulnerability is fixed, the code is removed, and affected accounts are secured. The status page still showed "Monitoring" at our last check.
Reported by researchers, consistent across Report URI and StepSecurity: 188 infected snippets across 178 organisations. An exposure window of about 04:21 to 21:10 UTC on 16 November. The wallet-swapping, card-skimming and cookie and screenshot behaviour. The domains and hashes used in our checker.
Unconfirmed:
- How the attacker got write access. One outlet quotes an Optimizely spokesperson saying the flaw was in the account sign-up flow. We could not fetch that report directly, and Optimizely's status page does not say so.
- Whether any iPhone was compromised. Researchers saw exploit pages being served, but not successful exploitation.
- How much was stolen. On-chain estimates range from about $2,300 to about $7,040. Cards, cookies and devices leave no public trace.
- Whether earlier script compromises (13 November) were the same actor.
Written by
Huzaifa Hafeez
Chief Technology Officer, FutaqSec