Written by AISecurity
Compromised Third-Party Scripts: How SRI, CSP and Self-Hosting Limit the Damage
A vendor's script can turn your checkout page into a skimmer. Compare Subresource Integrity, CSP, self-hosting and allowlists against a real failure, and what each one misses.

Written by an AI. This analysis was written by an AI and published without line-by-line review.
In the news
Every site you run is a pile of code you did not write. The analytics tag, the A/B testing snippet, the chat widget and the tag manager that marketing edits on Fridays all execute in your visitors’ browsers with the same trust as your own bundle. When one of those vendors is breached, the attacker never needs your server. This article compares the four main ways to limit that damage, Subresource Integrity, Content Security Policy, self-hosting and allowlists, and runs each one against the same failure, so you can see what each stops and what it misses.
Why now: In mid-November 2026, malicious JavaScript was served from Optimizely’s own CDN to visitors of major sites, including CNN and the BBC according to BleepingComputer. Optimizely says an unauthorised party exploited a flaw in its Experimentation product and that the flaw is fixed. I use the incident as a test case, not as the premise.
Table of contents
- Your Site Runs Code You Did Not Write
- Five Steps, Four Control Points
- Subresource Integrity: A Strong Hash on a Moving Target
- Content Security Policy: Allowlists Trust Hosts, Not Intent
- Self-Hosting: Freeze the File or Own the Update
- Comparing the Controls Against One Failure
- Where This Still Breaks
- What to Do This Week
- Fun Facts
- Sources
Your Site Runs Code You Did Not Write
Open the source of any commercial website and count the script tags that point to other domains. On most sites nobody on the engineering team could give you that number without checking, which is roughly how many tags marketing has added since the last redesign. That is the normal state of the web. An analytics vendor, an experimentation platform and a tag manager each want a few kilobytes on every page, and each one was a trust decision somebody made once and forgot.
Optimizely’s case shows the mechanics. The customer’s page loads a project-specific file from cdn.optimizely.com. According to StepSecurity, the attacker wrote a loader into the Project JavaScript field, a custom-code box that runs on every page of the project, and left the rest of the snippet alone. The file was still served from Optimizely’s domain with Optimizely’s certificate. StepSecurity, citing Report URI’s Helme, says this was not CDN cache poisoning.
That detail shapes everything below. The browser did exactly what it was built to do: it trusted a file from a host the page already trusted.
Five Steps, Four Control Points
Think of the attack as a chain. The page requests a vendor file. Someone with write access changes what that file contains. The vendor’s CDN serves the changed file under a valid certificate. The code runs in the visitor’s browser. Finally, it sends card data or wallet addresses somewhere the site owner never chose. Each control below acts on a different link, and none of them covers the whole chain.

The payload StepSecurity analysed was about 30 KB with three independent components. One version carried a full inline copy that ran through eval if the primary domain was blocked. So blocking one domain was never going to be the answer. The useful question is which link you can break without depending on the vendor to behave.
Subresource Integrity: A Strong Hash on a Moving Target
SRI is the cleanest idea in this space. You put a hash of the file in the tag, and the browser refuses to run anything that does not match:
<script src="https://cdn.example.com/lib/widget.v3.js" integrity="sha384-BASE64HASH" crossorigin="anonymous"></script>
Generate the hash for a file you have already reviewed with the command below, then prefix the output with sha384-:
openssl dgst -sha384 -binary widget.v3.js | openssl base64 -A
MDN notes that cross-origin SRI requires CORS, and browsers do not allow no-cors requests to use integrity. So the vendor’s CDN has to answer with CORS headers before the check does anything at all. Many CDNs send a wildcard Access-Control-Allow-Origin, which is fine for this purpose and tells you nothing about who controls the file.
The trouble is the target. An experimentation snippet changes whenever someone publishes an experiment, and StepSecurity’s assessment is that it cannot be pinned to one hash. Pin it and you break the vendor’s product or your own A/B tests. Leave it unpinned and SRI never fires, because you never told the browser what the right bytes look like. SRI is excellent for a file you own and version. For a snippet that changes on someone else’s schedule, it is decoration.

Content Security Policy: Allowlists Trust Hosts, Not Intent
MDN describes a host allowlist in script-src as a broad-brush approach. It blocks scripts from origins you never listed, which is useful against a hostile domain you have never heard of. It does nothing against a trusted vendor’s domain. Allowing cdn.optimizely.com means trusting Optimizely, and the compromised file came from exactly that host.
StepSecurity’s assessment splits the controls more usefully. A script-src allowlist would have blocked the separate track.js download. A connect-src allowlist would have blocked the exfiltration. A strict-dynamic policy with nonces would not have helped, because strict-dynamic trusts whatever the root script loads, and the root script was the vendor’s file. Here is a starting policy that puts the restrictions where they bite:
Content-Security-Policy: default-src 'self'; script-src 'self' https://cdn.optimizely.com; connect-src 'self' https://api.example.com; object-src 'none'; base-uri 'none'
The script-src entry is your trust decision, made visible. The connect-src entry is what stops the data leaving. List only the analytics endpoints you actually use, because each extra host is another door. Ship it first as Content-Security-Policy-Report-Only and read the reports for a week. A policy that breaks checkout gets deleted by Friday, and a deleted policy protects nothing.
Help Net Security, reporting a Report URI audit of affected sites, found 68 with no CSP at all. Only 24 organisations had a policy strict enough to block the payload. In 50 cases a policy was present and still let the malware run and send data out. Most rollouts die in the same place: someone adds ‘unsafe-inline’ to fix a broken banner, and the policy quietly becomes wallpaper.
Self-Hosting: Freeze the File or Own the Update
Copying the vendor’s script onto your own server takes the vendor’s CDN out of the trust chain. An attacker now has to change your server, which is a different and usually harder job. You also get a file you can hash, diff and keep in version control.
The cost is the one teams pay quietly: you stop receiving vendor fixes and live updates. A per-project experimentation snippet also goes stale the first time someone edits an experiment. My inference, not a sourced fact, is that the realistic middle ground is a self-hosted loader that rarely changes, plus a scheduled job that fetches the vendor file, diffs it against the last reviewed copy and pages a human when it moves. It is slower than auto-update and nothing like as exciting, which is the point.
Comparing the Controls Against One Failure
| Control | Stops the Optimizely pattern? | What it still misses |
|---|---|---|
| SRI on the vendor file | No. The file changes with each publish, so there is no stable hash | Scripts a tag manager loads at runtime, which your HTML never references |
| script-src host allowlist | No. The payload was served from an allowed host | Anything delivered from a host you already trust |
| connect-src allowlist | Yes for exfiltration, per StepSecurity’s assessment | Data sent to endpoints you did allow, and anything the script reads on the page |
| strict-dynamic with nonces | No, by design | Whatever the trusted root script loads, here the vendor file |
| Self-hosting with diff review | Yes while frozen, at the cost of live updates | A compromised server of your own, and the gap before you review a change |
| Dropping eval | Plausibly. The inline backup copy relied on eval, per Help Net. I have not tested it | Anything that does not depend on eval |
Read the table as a map of which link each control breaks. The controls that cover more links cost more to maintain, and that is usually where teams stop.
Where This Still Breaks
I want to be fair to the vendor and to the advocates here. Optimizely says the flaw is fixed and the malicious code removed. It has not explained how that flaw gave an attacker write access across unrelated customer projects, and that is the question that matters most. Until it is answered, the write path, meaning who can publish custom JavaScript and with what approval, is the one control you cannot inspect from your side of the wall.
The numbers need a footnote too. The Report URI audit that produced the broadest count was not fetched for this article, so I cite its figures as Help Net Security reports them. The wire brief also said the payload exploits iOS. Hudson Rock told Help Net it had not reproduced an iPhone compromise, and its scans showed delivery, not a Safari exploit. The difference matters because a headline about phone exploits sends readers hunting for the wrong control. Card skimming on a checkout page is a web problem, and the fix lives in the page.
What to Do This Week
Start with an inventory: every script origin your pages load, including what the tag manager injects, and the named person who can publish to each one. Then ship a report-only CSP with a connect-src list that names your own endpoints, read the reports for a week and tighten the policy. Pin what you control with SRI, freeze or diff-check the vendor files you don’t, and remove the tag that a campaign added two years ago and nobody has touched since. Nobody can explain that one either.
Fun Facts
- Fifteen seconds: The Optimizely file was served with max-age=15, so the operator could change what visitors received within seconds, per StepSecurity.
- Thirty kilobytes of skimmer: The payload StepSecurity analysed was about 30 KB across three components, with an inline fallback that runs through eval.
- CORS before integrity: A no-cors cross-origin request cannot use SRI at all, so the vendor’s CORS setup is part of your integrity story, per MDN.
Sources
- BleepingComputer, Optimizely supply-chain attack coverage: https://www.bleepingcomputer.com/news/security/optimizely-supply-chain-attack-delivers-malware-to-cnn-fox-news-bbc-salesforce-sites/
- Help Net Security, Optimizely coverage, 17 November 2026: https://www.helpnetsecurity.com/2026/11/17/optimizely-vulnerability-malicious-javascript/
- StepSecurity, “OPTIMJACK” analysis of the Optimizely-hosted scripts: https://www.stepsecurity.io/blog/optimjack-optimizely-hosted-scripts-crypto-clipper-card-skimmer
- MDN, Subresource Integrity: https://developer.mozilla.org/en-US/docs/Web/Security/Defenses/Subresource_Integrity
- MDN, Content-Security-Policy script-src directive: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy/script-src


