The Optimizely Attack: How a Trusted Script Served Malware to 178 Organizations
Attackers planted a card skimmer and crypto clipper in Optimizely-hosted scripts on 178 organizations' sites. How it worked, why most CSPs failed, what to fix.

On 16 November 2026, visitors to the websites of Zoom, the BBC, CNN, Salesforce, GitLab and about 170 other organizations ran an attacker’s JavaScript. None of their own servers or code was touched. The code arrived inside their Optimizely Web Experimentation snippet, the A/B-testing script that marketing teams load on every page, served from Optimizely’s own content delivery network. For roughly sixteen hours it swapped cryptocurrency addresses, skimmed card numbers typed into first-party payment forms, photographed pages and steered older iPhones toward exploit kits. Most of the affected sites had no browser-side control capable of stopping it.
Why this attack matters now
Third-party script compromises are not new. What makes this one instructive is the combination of scale, a clean evidence trail and a precise measurement of how defenses performed.
Scott Helme of Report URI, whose service collects browser security reports, documented the campaign while it was running. He found malicious code in 188 of the 1,611 Optimizely snippets he checked, belonging to 178 organizations, and warned that “the real number is likely higher” [2][9]. Banking and finance was the largest group, with 32 organizations [4]. Optimizely confirmed the incident on its status page on 17 November and published a fuller account on 18 November, saying fewer than 5% of its customers were affected [1].
Report URI also checked the Content Security Policy (CSP) of affected organizations’ own sites. CSP is the HTTP response header that tells a browser which sources a page may load scripts from and send data to. Of the sites it categorized, 68 had no CSP at all, 50 had a policy that let both the payload and the data theft through, 17 let the payload run but blocked the theft, and only 24 blocked the payload outright [2]. That breakdown is the most useful data point of the incident, and the rest of this article explains it.
Understanding the attack surface: what an experimentation snippet is
An experimentation platform changes a live page for a share of visitors, for example a different headline or button color, and measures the result. To do that, its script must run early, on every page, with full access to the Document Object Model (DOM): the page’s text, forms, links and scripts. In Optimizely Web Experimentation, the page loads one file per project, of the form cdn.optimizely.com/js/<project ID>.js, and some customers proxy it through their own domain [4].
Each project also has a Project JavaScript field: free-form code that the platform embeds in the snippet and runs on every page where the snippet loads [2][4]. It exists so that marketing and growth teams can add helper code without a website release. In security terms, it is a remote code-execution channel into the customer’s pages. It is controlled by whoever can sign in to the vendor’s console, and it sits outside the customer’s source control, code review and deployment pipeline.
That is the architectural fact the attacker exploited.
How the attack worked
Stage 1: write access through the vendor’s sign-up flow
Optimizely says an unauthorized party “exploited a flaw in the Optimizely Web Experimentation account signup flow”. It used that flaw “to impersonate users on targeted customer accounts” and insert JavaScript into those customers’ projects. Optimizely adds that “this was not a credentials breach” [1]. It has not published how a sign-up flaw allowed impersonation of existing customers’ users, and no CVE has been assigned. Before that statement, Report URI listed the possibilities as a compromised Optimizely system, a credential with cross-customer access, or “something else” [2]. Readers should treat the precise mechanism as unknown.
What is established is the result: the attacker could edit Project JavaScript in many unrelated customer projects. StepSecurity and Deepwatch both note that this was not CDN cache poisoning. The CDN faithfully served what the platform gave it [4][6].
Stage 2: three loaders, one payload
The first injection Report URI observed was in the BBC’s snippet at 04:21 UTC on 16 November, loading code from webshell[.]lol [2][4]. The domain that hosted the main payload, 1688360[.]cc, was registered about an hour later [4]. Researchers documented three loader variants [2][4][7]:
- A plain
<script>tag pointing tohttps://1688360[.]cc/track.js. - The same URL encoded in base64 and decoded at runtime with
atob(), so that a text search for the domain finds nothing. - A complete inline copy of the payload, executed through
evalif the remote domain was blocked.
The third variant matters for defenders. A policy that blocks the external domain but permits 'unsafe-eval' still runs the full payload. Report URI saw exactly that on HSBC’s site, and notes that Optimizely’s documentation has told customers to allow 'unsafe-eval' [2][9].
Stage 3: what the payload did
The payload was rebuilt 26 times during the day, and the card skimmer was only added at 13:43 UTC [4]. StepSecurity, which ran its own infrastructure checks, describes these modules; Socket’s static decode of an early sample, done without executing it, confirms the clipper and the iOS loader [4][5]:
- Crypto address clipper. It replaced checksum-valid wallet addresses for Ethereum and EVM chains, TRON, Bitcoin, TON, Solana, Litecoin, Bitcoin Cash and Dogecoin. It acted only when nearby text contained words such as “wallet”, “deposit” or “send”. It rewrote addresses in page text, form fields, the clipboard and outgoing
fetchandXMLHttpRequestcalls. - Screenshot and cookie theft. After a swap, it rendered the page to an image with the open-source html2canvas library. It posted the image, the URL and up to 8,000 characters of
document.cookieto/hit.php. - Card skimmer. It hooked form submissions and network calls, looked for a Luhn-valid card number with expiry and CVV, and sent the data to
/card.phpwithnavigator.sendBeacon. - iOS routing. For iPhone, iPad and iPod user agents, it loaded
boot.jsfrom.icudomains. On iOS 18.6 and earlier, it also added a hidden iframe and reloaded the page every 60 seconds. The scripts led to the Coruna and DarkSword exploit kits, which target older iOS versions. Patched releases are iOS 18.7.3 and 26.3 or later [4][6].
Figure 1 traces the path from the vendor console to the visitor’s browser. Look at where the trust boundary sits: everything the attacker touched is outside the customer’s infrastructure.
Figure 1. The OPTIMJACK attack chain. The customer’s own servers and code were never touched; the browser executed what a trusted vendor origin served.
What is known about impact
Clean-up began around 20:40 UTC. Report URI found all infected files clean by 23:11 UTC [2]. Estimates of cryptocurrency stolen range from about $2,300 actually sent by victims (Galaxy Digital) to about $7,000–$7,500 received by the attacker’s wallets (Report URI). The higher figures include wallet activity that predates the attack [4][7][8]. The number of skimmed cards is unknown: Report URI says it cannot see how many reached the attacker’s server [2]. No source has confirmed a successful iPhone compromise. StepSecurity notes that public scans show “exploit pages being delivered, not an exploit succeeding” [4]. The campaign is unattributed. Deepwatch maps it to MITRE ATT&CK techniques including T1195.002 (Compromise Software Supply Chain), T1189 (Drive-by Compromise), T1056 (Input Capture), T1115 (Clipboard Data) and T1113 (Screen Capture) [6][13].
Why conventional defenses did not stop it
The external domain names do not tell the whole story. Four common assumptions failed.
“We only load scripts from approved vendors.” True for every victim. Supplier approval and CSP host allowlists both answer where code comes from. The malicious code came from cdn.optimizely.com, an approved origin. As Report URI put it, allowing that domain “was never going to help” [2].
“Our CSP protects us.” It depended on how the CSP was written. A script-src host allowlist that did not include 1688360[.]cc would block the second-stage download. But many modern policies use 'strict-dynamic' with a nonce, where a script that a trusted script adds to the page inherits that trust [12]. StepSecurity notes that such a policy does not block this payload [4]. That matters because Optimizely’s current CSP guidance recommends exactly this pattern: a nonce on the snippet tag plus 'strict-dynamic' [10]. A customer that followed the vendor’s advice to the letter had a modern, well-formed policy that trusted whatever the snippet loaded. Policies that allow 'unsafe-eval' let the inline fallback run.
“Subresource Integrity (SRI) pins our third-party scripts.” SRI makes the browser refuse a script whose hash does not match a value in the page. It works for versioned libraries. An experimentation snippet changes every time someone publishes an experiment, so a fixed hash breaks the site within days [3][4]. In practice, few customers can pin it.
“Our security team monitors our infrastructure.” The servers, code repositories and deployment logs of the victims recorded nothing, because nothing in them changed. The only reliable signal was in visitors’ browsers. The organization’s own Security Information and Event Management (SIEM) platform sees employees’ devices, not customers'.
Our analysis: three lessons the incident teaches
1. The trust boundary moved to a vendor’s sign-up form. For sixteen hours, the integrity of 178 websites depended on the account-provisioning logic of a marketing tool. Typical third-party risk assessments look at certifications and breach history. They rarely ask the question this incident makes central: who, outside our change control, can publish code that runs in our customers’ browsers, and how is that write path protected?
2. Containment beat provenance. The 17 sites where the payload ran but exfiltration failed show that restricting what code can reach is more robust than restricting where it comes from. A tight connect-src directive blocked the theft even though the malicious script executed. Two other controls, built for different reasons, also capped the damage. Hosted payment fields in a cross-origin iframe were out of the skimmer’s reach. HttpOnly session cookies were invisible to document.cookie [4].
3. The attacker iterated in production, so point-in-time reviews miss it. Twenty-six payload builds, a skimmer added mid-afternoon, and Smartsheet’s snippet being re-infected after clean-up with the encoded variant [4] are behaviors that a quarterly script inventory cannot see. Report URI measured the campaign by repeatedly crawling and re-checking snippets throughout the day [2]. Continuous checking of what is actually served is the control that matches how this attacker worked.
The technology behind the defense
Client-side defense is a set of controls that each cover a different stage. Figure 2 maps them to the attack chain and to what they achieved in this incident.
Figure 2. Where each control acts. No single control stops every stage; the incident data shows connect-src and payment-page isolation limited damage even where the payload ran.
Content Security Policy, written for containment
What it does: the browser enforces source restrictions per resource type. The directives that mattered here are script-src (where scripts may load from), connect-src (where fetch, XHR and sendBeacon may send data) and the absence of 'unsafe-eval' and 'unsafe-inline'. The report-to directive (or the older report-uri) makes the browser send a violation report for each blocked action, so the policy is also a sensor.
Implementation: deploy in Content-Security-Policy-Report-Only mode first, collect reports for a few weeks, then enforce. The example below is illustrative, not production-validated. It is wrapped across lines for readability; a real header is a single line. Vendor endpoints must come from each vendor’s own documentation, and a broad wildcard such as *.optimizely.com in connect-src is itself an exfiltration path if that vendor is abused.
Content-Security-Policy:
default-src 'self';
script-src 'self' https://cdn.optimizely.com;
connect-src 'self' https://<experimentation-event-endpoint>;
img-src 'self' data: https://cdn.optimizely.com;
frame-src https://<payment-provider-hosted-fields>;
form-action 'self';
object-src 'none';
base-uri 'self';
report-to csp-endpoint
Reporting-Endpoints: csp-endpoint="https://<your-csp-report-collector>/csp"
Limitations: a host allowlist trusts everything a listed host serves, which is how stage 1 succeeded. Features that need 'unsafe-eval' reopen the fallback path, so decide per page. Image and navigation requests can still carry small amounts of data, so img-src and form-action also deserve attention. The example deliberately uses a host allowlist rather than 'strict-dynamic'. Validation: in a staging copy, inject a harmless script that tries to load from and post to an unlisted domain, and confirm both are blocked and reported.
Script inventory and change detection
What it does: it records which scripts every sensitive page loads, and alerts when the content or behavior of a served script changes. This is the intent of PCI DSS v4.0.1 Requirements 6.4.3 (inventory and authorization of payment-page scripts) and 11.6.1 (change and tamper detection), both mandatory since 31 March 2025 [11][14]. Merchants that validate with SAQ A no longer report against these two requirements directly, but the PCI Security Standards Council stresses that the underlying requirements are not diminished [15]. Commercial client-side protection products and CSP-report services provide this. A team can also build a basic version, as in the illustrative sketch below. It extracts the external hostnames referenced by a served snippet and flags any not seen before.
# Illustrative sketch: alert on new hostnames or risky constructs in a third-party snippet.
# Run on a schedule; the first run records a baseline; review every alert, then update the baseline.
import re, urllib.request, json, pathlib
SNIPPET = "https://cdn.optimizely.com/js/<project-id>.js"
BASELINE = pathlib.Path("snippet-baseline.json")
HOST_RE = re.compile(r"(?:https?:)?\\?/\\?/([a-z0-9.-]+\.[a-z]{2,})", re.I) # also matches https:\/\/ and //host
RISKY = ("atob(", "eval(", "new Function(", "sendBeacon")
body = urllib.request.urlopen(SNIPPET, timeout=15).read().decode("utf-8", "replace")
seen = {"hosts": sorted(set(HOST_RE.findall(body))), "risky": [k for k in RISKY if k in body]}
if not BASELINE.exists():
BASELINE.write_text(json.dumps(seen))
raise SystemExit("baseline recorded")
known = json.loads(BASELINE.read_text())
alert = {k: sorted(set(seen[k]) - set(known[k])) for k in seen}
if any(alert.values()):
print(json.dumps(alert)) # send to your alerting pipeline; update the baseline only after review
Limitations: the base64 loader hides its hostname, which is why the sketch also flags atob( and eval(. Legitimate snippets may contain those constructs too, which is why they are compared against the baseline rather than alerted on outright. This approach does not see conditional payloads that a server only delivers to some visitors. Rendering the page in a headless browser and recording its network requests closes more of that gap.
Governance of the vendor console
The write path into Project JavaScript is an identity problem. Require single sign-on (SSO) with phishing-resistant multi-factor authentication (MFA) for the experimentation console. Limit who can edit project-wide code. Review API tokens. Subscribe to the platform’s change history or audit log, if it offers one. None of this would have stopped a vendor-side impersonation flaw like this one. It does close the much more common route of a stolen marketer’s password.
Payment-page and session architecture
Hosted payment fields served from the payment provider’s origin in an iframe keep card data outside the reach of any script on the merchant’s page. The HttpOnly cookie attribute does the same for session tokens. Both proved their value here without anyone needing to detect the attack [4]. Where possible, keep experimentation and tag-manager scripts off checkout, login and account pages entirely. Socket similarly urges organizations to reconsider running them on payment and account pages [5].
Practical implementation guide
Immediate actions (24–72 hours)
- If you use Optimizely Web Experimentation, read Optimizely’s direct notice to your account [1]. Then inspect every project’s Project JavaScript and custom experiment code for
1688360,atob(,eval(and anything you did not write [2]. Check snippets served from your own domain too. - Rotate access. Review console users, API tokens and integrations with write access, and rotate them [2][6].
- Search egress and DNS logs from 04:00 UTC on 16 November at minimum [4] for
1688360[.]cc,webshell[.]loland the.icuhosts listed by StepSecurity. Report URI sawwebshell[.]lolon unrelated sites as early as September, so search further back for that domain if retention allows [2]. The illustrative Microsoft Sentinel query below finds employees’ devices that contacted them. It does not show customer exposure.
// Illustrative: managed devices that reached OPTIMJACK infrastructure.
// Requires Defender for Endpoint data in Sentinel. Example IOCs only: take the full list from [4].
// RemoteUrl is often empty for HTTPS; also check DNS (DeviceEvents, ActionType == "DnsQueryResponse") or proxy logs.
let iocs = dynamic(["1688360.cc", "webshell.lol", "5vobauua3ojpklx.icu", "eil786npto9u5bq.icu"]);
DeviceNetworkEvents
| where TimeGenerated between (datetime(2026-11-16T04:00:00Z) .. now())
| where RemoteUrl has_any (iocs)
| summarize Hits = count(), First = min(TimeGenerated), Last = max(TimeGenerated) by DeviceName, RemoteUrl
- Treat exposure as real if your snippet was infected. Cards typed into first-party forms from 13:43 UTC on 16 November [4] and secrets held in non-HttpOnly cookies should be considered compromised. Involve your payment processor and legal counsel about notification duties. Make sure managed Apple devices are on iOS 18.7.3, 26.3 or later [2][4].
Medium-term improvements (30–90 days)
- Deploy CSP in report-only mode on all customer-facing sites, starting with checkout, login and account pages. Then enforce a policy that restricts
connect-srcand avoids'unsafe-eval'where features allow. - Build a third-party script inventory per page. Record the owner, the business purpose and who can change each script’s content.
- Add served-script change monitoring for payment pages to meet PCI DSS 6.4.3 and 11.6.1 in substance, not just on paper.
- Move card entry to hosted fields if it is not already there, and set HttpOnly, Secure and SameSite on all session cookies.
Strategic improvements
- Add “who can publish code to our customers’ browsers?” to vendor risk assessments. Ask vendors how that write path is authenticated, logged and isolated between tenants.
- Treat marketing technology as part of the software supply chain: code-review or approval gates for project-wide code, change notifications into the Security Operations Center (SOC), and an owner for every tag.
- Run client-side security exercises. Inject a benign “malicious” tag through each third-party channel and measure whether CSP, monitoring and the SOC catch it.
What organizations should do next
Executives should ask for a list of every vendor that can change code on customer-facing pages, and treat it as a material risk register. Security architects should design CSP for containment rather than provenance, and isolate payment and authentication flows from third-party code. Web and platform engineers should treat CSP reports and script inventories as production signals with an on-call owner, not compliance artifacts.
Conclusion
OPTIMJACK did not need a vulnerability in any victim’s code. It needed one weakness in a vendor’s account logic and the industry’s habit of treating “approved origin” as “trusted code”. The measurement Report URI published is the real lesson. Organizations that limited where page scripts could send data, kept card entry in an isolated frame and kept session cookies out of JavaScript’s reach lost little or nothing, even when the malicious code ran. The next third-party compromise will come through a different vendor. The controls that held this time will work the same way.
Frequently asked questions
What happened in the Optimizely supply-chain attack?
On 16 November 2026, an attacker exploited a flaw in Optimizely Web Experimentation’s account sign-up flow to impersonate users on customer accounts. The attacker added malicious JavaScript to their projects. Optimizely’s CDN then served it to visitors of 178 organizations’ websites, including Zoom, the BBC and CNN, until clean-up finished late that day.
What did the malicious code do?
It replaced cryptocurrency wallet addresses with the attacker’s, skimmed card numbers typed into first-party payment forms, captured screenshots and non-HttpOnly cookies, and routed older iPhones toward exploit kits. No source has confirmed a successful iPhone compromise.
Would a Content Security Policy have stopped it?
It depended on the policy. A script-src host allowlist without strict-dynamic would block the second-stage download, and a strict connect-src would block data theft. Policies using strict-dynamic, or allowing unsafe-eval, let the payload run. Allowing Optimizely’s own domain gave no protection, because the code came from that domain.
Was my organization affected?
Optimizely says it contacted every Web Experimentation customer directly. If you use the product, check its notice, inspect Project JavaScript and custom code for unfamiliar content, and search egress and DNS logs from 16 November for the published indicators.
References
- Optimizely, “Web Experimentation Security Incident”, status page, updates 17 November 2026 01:02 UTC and 18 November 2026 14:49 UTC. https://status.optimizely.com/incidents/ftw0fh9wx43z
- Scott Helme, Report URI, “World’s largest brands infected with malware via Optimizely”, 16 November 2026 (updated 17 November 2026). https://blog.report-uri.com/worlds-largest-brands-infected-with-malware-via-optimizely/
- Scott Helme, “Reflecting on the Optimizely incident and why we keep failing”, 17 November 2026. https://scotthelme.co.uk/reflecting-on-the-optimizely-incident-and-why-we-keep-failing/
- Owais Shaikh, StepSecurity, “OPTIMJACK: Optimizely-Hosted Scripts Loaded a Crypto Clipper and Card Skimmer on 178 Organizations”, 17 November 2026 (updated 20 November 2026). https://www.stepsecurity.io/blog/optimjack-optimizely-hosted-scripts-crypto-clipper-card-skimmer
- Taym Haddadi, Socket, “Optimizely Supply Chain Attack Distributes Malware Across Global Brands”, 18 November 2026. https://socket.dev/blog/optimizely-supply-chain-attack
- Deepwatch Adversary Tactics and Intelligence Team, “CA-26-048: OPTIMJACK – Optimizely Web Experimentation Supply Chain Attack”, 18 November 2026. https://www.deepwatch.com/labs/ca-26-048-optimjack-optimizely-web-experimentation-supply-chain-attack/
- Lawrence Abrams, BleepingComputer, “Optimizely hack infected CNN, Fox News, BBC, Salesforce sites with malware”, 16 November 2026. https://www.bleepingcomputer.com/news/security/optimizely-supply-chain-attack-delivers-malware-to-cnn-fox-news-bbc-salesforce-sites/
- Brian Krebs, KrebsOnSecurity, “Attackers Used Optimizely to A/B Test Malware on Top Websites”, 17 November 2026 (updated 18 November 2026). https://krebsonsecurity.com/2026/11/attackers-used-optimizely-to-a-b-test-malware-on-top-websites/
- Sinisa Markovic, Help Net Security, “Malware spread through Optimizely hits 178 organizations, including BBC, CNN and Zoom”, 17 November 2026. https://www.helpnetsecurity.com/2026/11/17/optimizely-vulnerability-malicious-javascript/
- Optimizely Developer Documentation, “Update your site’s Content Security Policies (CSP)” (accessed 20 November 2026). https://docs.optimizely.com/web-experimentation/docs/update-your-site-s-content-security-policies-csp
- Cloud Security Alliance, “PCI DSS 6.4.3 and 11.6.1: A Deep Dive into Payment Page Security and Integrity Requirements”, 23 July 2026. https://cloudsecurityalliance.org/blog/2026/07/23/pci-dss-6-4-3-and-11-6-1-a-deep-dive-into-payment-page-security-and-integrity-requirements
- MDN Web Docs, “Content-Security-Policy: script-src directive” (‘strict-dynamic’). https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy/script-src
- MITRE ATT&CK, “Supply Chain Compromise: Compromise Software Supply Chain (T1195.002)”. https://attack.mitre.org/techniques/T1195/002/
- PCI Security Standards Council, “Coffee with the Council Podcast: Guidance for PCI DSS E-commerce Requirements Effective After 31 March 2025”. https://blog.pcisecuritystandards.org/coffee-with-the-council-podcast-guidance-for-pci-dss-e-commerce-requirements-effective-after-31-march-2025
- PCI Security Standards Council, “Important Updates Announced for Merchants Validating to Self-Assessment Questionnaire A”. https://blog.pcisecuritystandards.org/important-updates-announced-for-merchants-validating-to-self-assessment-questionnaire-a