groundy
Security

Optimizely Malware Hit 178 Sites: Can CSP Contain Third-Party Scripts?

Report-uri data shows restrictive CSP script-src blocked Optimizely malware on 24 sites, while connect-src only stopped data theft. Verify deployed policies.

Published 5 references
Black ceramic thorns emerge from a chipped ivory pipe and press against a closed forest-green gate with a copper-colored hinge, casting hard shadows on a warm ivory background.
On this page13 sections

CSP can contain a compromised third-party script, but only when the browser enforces a policy that restricts what that script can load and where it can send data. In report-uri’s self-reported incident evaluation, 256 affected hosts were crawled and 24 organisations were classified as blocking the payload. Another 17 blocked data theft with connect-src, but the attacker’s wallet-address swapping still worked.

That distinction should drive the response. Allowlisting a vendor’s domain does not bound the damage when the vendor itself serves the compromised code. The useful controls are an enforcement-mode CSP with a restrictive script-src, a minimal connect-src, monitoring for script changes, and a deliberate decision about which pages need the tag at all. Payment pages should not load experimentation or marketing tags by default.

A trusted platform became the delivery mechanism

On 2026-11-16, malicious JavaScript was served through the Optimizely Web experimentation platform, according to report-uri’s disclosure. The 178 figure needs precision: report-uri says it fetched 1,611 distinct Optimizely snippets and found 188 infected snippets belonging to 178 organisations. It also says the real number was likely higher because it could only check snippets found in time.

Report-uri describes a multi-purpose kit that swapped cryptocurrency wallet addresses, skimmed payment cards, stole cookies and screenshots, and delivered the Coruna and DarkSword iOS exploit kits on iPhones and iPads. The same vendor report says attacker wallets had received about $7,040 by 19:25 UTC on 2026-11-16, within roughly nine hours. Named organisations included Zoom, the BBC, CNN, Salesforce, GitLab, IKEA, HSBC, Equifax, Air France-KLM, Ledger and Peacock.

These figures are self-reported by report-uri, which sells script-integrity monitoring and CSP tooling. Wikipedia’s Optimizely entry repeats the date, scale and discovery attribution to security researcher Scott Helme, citing Cyber Security News coverage from 2026-11-17. That is useful secondary corroboration, but it traces back to the same disclosure rather than independently reproducing the technical analysis.

Optimizely’s reach explains why this delivery route matters. The product began as a tool for running A/B experiments before becoming part of a broader digital experience platform, as Mando Group’s product history describes. Report-uri explains that the compromised Project JavaScript was custom code that “runs on every page”. The potential blast radius was therefore every page loading an affected snippet, including conversion and payment flows.

The origin was trusted; the policy still had choices

The important architectural point is that origin trust and script behavior are different things. Report-uri says the malicious code arrived from the trusted Optimizely host, so simply permitting cdn.optimizely.com could not establish that the resulting execution was safe.

The payload then had several CSP-relevant dependencies. According to report-uri’s analysis, it loaded track.js from 1688360.cc, had an inline fallback requiring 'unsafe-eval' or 'unsafe-inline', sent stolen data to 1688360.cc, and loaded the iOS kit through script or frame loading. Those dependencies gave a well-designed policy several places to intervene.

This is also why a restrictive script-src is not contradictory to using Optimizely. A policy might need to permit the vendor snippet while still refusing an additional, unneeded host. The initial snippet can be trusted to load without being trusted to authorize every subsequent script.

Tag-manager-style deployment makes that distinction harder to govern. A study of Google Tag Manager explains that, once installed, a tag management system automatically installs and executes the third-party tags selected by the publisher without requiring changes to the site’s source code. The same measurement study, citing BuiltWith, places Google Tag Manager on 52% of the top one million websites and more than 60% of the top 10,000. Those figures describe Google Tag Manager, not Optimizely, but they demonstrate why runtime tag injection is a mainstream operating model rather than an unusual edge case.

The governance problem extends beyond malware. In that study’s examination of 718 Google Tag Manager tags, researchers reported hidden data leaks, unclear documentation, undisclosed third parties and personal-data sharing without consent. That work concerned privacy and legal exposure, not this attack, but it supports a narrower conclusion: publishers may not have a complete inventory of what their tags load or communicate with.

Enforcement and report-only are different controls

CSP’s two deployment modes should not be treated as interchangeable levels of protection. A CSP measurement study of the Tranco top 50,000 sites defines enforcement mode as blocking policy violations, with optional reporting. In report-only mode, the browser reports violations to the configured reporting endpoint but does not enforce the policy.

Report-only can therefore be useful while developing a policy: it can reveal unexpected scripts and connections before blocking is enabled. It would not have stopped this payload. A report showing an attempted connection to 1688360.cc is detection evidence, not containment.

Report-only also requires the Content-Security-Policy-Report-Only response header and cannot be deployed through the HTML meta tag, according to the same CSP study. Checking only page markup can therefore miss how the policy is actually deployed. Engineers need to inspect the response headers received by visitors.

The incident outcomes reported by report-uri show why “has CSP” is too coarse a classification:

Reported outcomeOrganisationsPractical consequence
No CSP at all68No CSP intervention
CSP allowed the payload and data theft50Policy present, but ineffective against these dependencies
Payload ran; connect-src blocked data theft17Exfiltration blocked, but wallet-address swapping continued
Payload blocked24The vendor attributes this to restrictive script-src policies

The table is report-uri’s self-reported classification, not an independent reproduction. The disclosure labels the final row “24 (15%)”, and its four outcome rows sum to 159 of the 256 crawled hosts. That sum explains the percentage: 24 of 159 is 15.09%, so the vendor’s “15%” almost certainly uses the 159 classified hosts as its denominator rather than all 256 crawled hosts, where the share would be about 9%. The remaining 97 crawled hosts never appear in an outcome row. The disclosure does state its evaluation criteria, the four payload dependencies it evaluated against, but it does not publish per-site policies, leaving the basis for each result unexplained.

The policy settings that mattered

Report-uri says the sites that blocked the payload used restrictive script-src host allowlists. A site listing only the hosts it needs would not permit the reported second-stage host, 1688360.cc.

Report-uri identifies two common settings that defeated that containment:

  • 'strict-dynamic' allows trust to propagate to scripts inserted by an already trusted script. In this case, the vendor says scripts inserted by the trusted Optimizely snippet inherited that trust. A feature often useful for dynamic tag-loading workflows therefore conflicted directly with containment.
  • 'unsafe-eval' and 'unsafe-inline' mattered because the payload had an inline fallback dependent on those permissions. Removing unnecessary permissions reduces the available execution paths, although the disclosure does not independently test every possible policy combination.

This creates a real migration cost. If a site’s tag workflow depends on trust propagation, adding a host allowlist or removing 'strict-dynamic' may require an inventory of scripts that currently appear only at runtime. Switching the policy without that work could break legitimate experiments or tags.

I would use report-only as a staging mechanism for that inventory, then move to enforcement on sensitive pages. I would not leave report-only in place and describe the resulting telemetry as protection. Where the workflow cannot yet operate under a restrictive policy, removing the tag from checkout and payment pages is a more dependable interim exposure reduction than assuming monitoring will catch every change quickly enough.

connect-src can prevent theft without preventing fraud

The 17 partial-containment outcomes are the clearest warning against treating any single CSP directive as a complete answer. According to report-uri’s results, connect-src blocked the payload’s data theft on those hosts, but wallet-address swapping still worked.

The mechanism is straightforward. Changing an address displayed in the page does not require the same outbound connection as sending stolen card data or cookies to the attacker. A network-destination policy can therefore prevent one loss while leaving another intact.

A minimal connect-src remains worthwhile because it can limit exfiltration when script containment fails. It should sit behind a restrictive script-src, not substitute for one. The reported iOS delivery path also makes frame-src relevant, since a policy governing scripts and connections alone may not address every frame load.

SRI has a narrower scope than the tag workflow

Subresource Integrity can pin a page-referenced resource to an expected fingerprint. That makes it relevant to a static snippet whose contents unexpectedly change, and report-uri identifies a changed Optimizely snippet fingerprint as one of the incident’s detection signals.

It does not follow that SRI can pin everything a tag manager subsequently injects. The tag-manager research establishes that third-party tags are installed and executed at runtime without corresponding changes to the site’s source code. A page-level integrity attribute can cover a resource referenced by that page, but it cannot retroactively pin a brand-new child script selected and inserted by the runtime tag.

That is an architectural inference from the tag-manager execution model, not a tested SRI result from the Optimizely incident. SRI may still be appropriate for stable, directly referenced assets; experimentation snippets may be expected to change, and pinning one without a process for reviewing and updating the expected fingerprint could turn normal vendor updates into site breakage. It should not be presented as complete coverage for runtime-injected tag-manager scripts.

Monitoring helps, but read the vendor’s claim accordingly

Report-uri says two signals would have exposed this compromise: the Optimizely snippet’s fingerprint changing and a brand-new script with no matching known file. Those are sensible things to monitor because they address both modification of a trusted resource and expansion into an unknown one.

Incident-specific searches can also use the published indicators. Report-uri lists new data destinations at 1688360.cc/hit.php and 1688360.cc/card.php in its indicator set. The same disclosure identifies eil786npto9u5bq.icu as a new iframe source and flags 5vobauua3ojpklx.icu, webshell.lol and 1688360.cc as indicators of compromise.

Monitoring still needs an honest role in the defense model. Detecting a changed fingerprint or unknown script can shorten exposure; it does not establish that execution was blocked before visitors were affected. Report-uri’s claim that its own monitoring would have detected the attack is also commercially interested; no independent validation appears in the cited coverage. The detection signals remain useful, but they should not be treated as proof of a particular product’s effectiveness.

Verify the deployed policy, not just its design

Even a nominally strong CSP can be weakened by implementation errors. In a study of nonce-based policies, researchers found that 598 of 2,271 sites reused the same nonce value across responses, potentially allowing attackers to bypass the CSP’s XSS protection.

That study examined nonce reuse and XSS, not this Optimizely kit, so it does not show that nonce reuse contributed to any of the reported compromises. Its relevance is narrower: the policy written in configuration is not necessarily the protection browsers consistently receive. Reviewing actual responses belongs in the audit.

A practical tag and policy triage

  1. Map where each vendor tag executes. Include Optimizely, tag-manager containers and scripts inserted by other marketing tools. Identify checkout, payment, authentication and cryptocurrency-related pages explicitly. The blast radius is the set of pages where the tag runs, not merely the page where someone originally configured it.

  2. Inspect the response CSP on each important template. Distinguish Content-Security-Policy from Content-Security-Policy-Report-Only. A reporting header can produce useful telemetry but does not block violations.

  3. Review script-src by behavior, not vendor reputation. Identify every required host and flag 'strict-dynamic', 'unsafe-eval' and 'unsafe-inline' for justification. Do not assume that permitting cdn.optimizely.com says anything about whether additional runtime hosts should be allowed.

  4. Minimise network and framing permissions. Compare connect-src with the destinations each page genuinely needs, and review frame-src separately. Treat this as a second containment layer: it may stop exfiltration even when in-page manipulation remains possible.

  5. Establish a script-change baseline. Track the vendor snippet’s fingerprint, newly appearing runtime scripts and new data destinations. Search available historical telemetry for the published indicators, while recognizing that blocking only those domains would not address the next compromised vendor or payload.

  6. Check nonce behavior in actual responses. If the policy depends on nonces, verify that values are not reused across responses rather than assuming the implementation matches the intended design.

  7. Remove tags from payment pages unless their presence is necessary and governed. If an experiment genuinely must run there, require the tighter enforced policy and monitoring rather than treating the page like a general marketing template.

The evidence supports a clear but bounded choice: enforcement-mode CSP with a restrictive script-src, no unnecessary trust propagation or unsafe execution permissions, and a minimal connect-src is the only client-side control report-uri’s data identifies as having blocked this payload. Monitoring adds detection, and page placement reduces exposure before policy has to work.

What the evidence cannot establish is how often that result will repeat. The incident and containment figures come from one vendor with a product interest, and the disclosure does not publish its per-site CSP policies. Neither Optimizely nor an affected organisation had issued a statement in the coverage cited here. That absence in the cited coverage is not proof that no such statements exist. Until independent technical confirmation is available, treat the incident figures as a serious audit trigger rather than a universal measurement of CSP effectiveness.

Frequently Asked Questions

Which CSP settings blocked the Optimizely malware payload?

Report-uri says the sites that blocked the payload used restrictive script-src host allowlists. A site listing only the hosts it needs would not permit the reported second-stage host, 1688360.cc.

Why did connect-src not fully stop the attack?

According to report-uri’s results, connect-src blocked the payload’s data theft on those hosts, but wallet-address swapping still worked.

How many organizations were affected by the Optimizely malware?

The 178 figure needs precision: report-uri says it fetched 1,611 distinct Optimizely snippets and found 188 infected snippets belonging to 178 organisations.

References

Follow the links in the article for context. The supporting material is collected here for further reading.

  1. report-uri's self-reported incident evaluationblog.report-uri.comAccessed
  2. Optimizely entryen.m.wikipedia.orgAccessed
  3. Mando Group's product historymandogroup.comAccessed
  4. measurement studyarxiv.orgAccessed
  5. CSP measurement study of the Tranco top 50,000 sitesarxiv.orgAccessed

Join the discussion

Share a useful perspective or ask a question about this article.

Discussion guidelinesComments privacy