
Auditing Third-Party Script Loads for Malware After a Tag Vendor Breach
I can't audit Optimizely's infrastructure, and I won't pretend public reporting gives me enough to reconstruct their attack path. What I can audit is the thing that decides whether a tag vendor breach becomes your breach: the origins your own HTML tells the browser to trust.
This post walks that audit end to end. You'll enumerate every third-party script origin you actually load, trace how a compromised container reaches a visitor's browser, and deploy controls that bound the damage when the next vendor gets hit. Along the way there's a first-hour triage runbook, DOM telemetry you can paste into a console, an honest assessment of what CSP and SRI can and cannot do against a tag manager, and an isolation playbook for cutting a vendor off in minutes.
The November 17, 2026 reporting says attackers exploited an Optimizely vulnerability to inject malware into customer websites, that 178 organisations' sites were affected, and that coverage links the campaign to cryptocurrency theft. Those are the facts I'll use. Everything below about how the injection worked is unconfirmed, and I'll mark it as such.
178 is the least useful number in that list. What matters is that all 178 had already given a third-party origin permission to execute arbitrary JavaScript inside their document, and most had no way to notice when that permission was used.
On this page
What the Optimizely Reporting Confirms and What It Leaves Open
I'm keeping this split strict. The incident will attract plenty of confident retellings, and I don't want to add one.
| Claim | Status |
|---|---|
| A vulnerability in Optimizely was exploited to inject malware into customer sites | Stated by reporting |
| 178 organisations' websites were affected | Stated by reporting |
| The campaign is linked to cryptocurrency theft | Stated by reporting as a link, not a proven end-to-end chain |
| Which Optimizely component was vulnerable | Not established in the coverage I saw |
| Whether the injection was a server-side flaw, a console/account compromise, or a container-config write | Not established |
| Whether visitors had wallets drained, were cryptomined, or were redirected | Not established |
| Dwell time, first-seen timestamp, payload hashes | Not established |
I could fill those gaps with plausible guesses — a compromised admin session, stored XSS in a config editor, a poisoned container JSON — and every one would read like reporting. I'm not doing that. The defensive work below holds across all of those cases, because each one ends in the same place: attacker-controlled JavaScript running under your origin.
How a Tag Vendor Breach Reaches Your Users: The Blast-Radius Model
A tag manager is not an analytics tool that happens to run code. It is a remote code execution channel with a marketing UI on top. The pitch — "manage tags without deploys" — is exactly the dangerous property: the vendor can change what executes on your site without your review, and by design you cannot code-review it. That is a supply-chain relationship whether or not anyone calls it one.
Four trust tiers matter:
| Tier | What the vendor can do | Can you verify it at request time? |
|---|---|---|
| Analytics endpoint | Receive data you send it | Yes, by reading your own call sites |
| Server-side tag proxy | Transform and forward data | Partly — you control the proxy allowlist |
| Client-side container | Inject arbitrary script into your DOM | Only that the loader bytes match a hash |
| Container with custom HTML tags | Same as above, plus inline script with no URL at all | No — nothing to hash |
The last row is the one people forget. Almost every tag manager ships a "custom HTML" or "custom code" tag type because customers asked for it. That feature means that even without a memory-corruption bug or an auth bypass, anyone who can write to your container can write arbitrary JavaScript into your origin. A vendor-side compromise doesn't need to defeat browser security; it just uses the feature you paid for.
That's the position I'd defend in a review: treat container write access as equivalent to a production deploy permission on your frontend, and staff it that way.
Tracing a Vendor Compromise to the Visitor's Browser
The loader snippet is the trust anchor
Every one of these incidents starts with a line you pasted into a layout template years ago and haven't looked at since:
<script async src="https://cdn.tagvendor.example/container/v3/a1b2c3d4.js"></script>
That tag does three things, and all three are attack surface:
- It fetches the loader from a vendor origin. Whoever controls that origin controls the bytes.
- The loader fetches a container configuration document — usually JSON, sometimes JS — keyed by the container ID.
- The loader evaluates that configuration and injects the tags it describes:
<script src>, inline<script>,<iframe>, pixels, and whatever else the tag type allows.
Step 3 survives most incident response because the injected nodes never appear in your page source, your repo, or your build artifacts. They exist only in a live DOM after the loader runs.
Injected tags execute with your origin's privileges
There is no sandbox. A script injected by the container runs in the same document, the same realm, with the same origin. Concretely, it can:
- read
document.cookiefor every cookie withoutHttpOnly - read and rewrite
localStorageandsessionStorage - call
fetch(url, { credentials: "include" })and get your session cookies attached - read the contents of forms, including card fields you thought were hosted-field isolated, if any part of the flow is in your DOM
- call
history.pushState, rewrite links, and intercept clicks - register a service worker on your origin
- read other scripts' globals, including tokens some SPA put on
window
If that list looks like the XSS impact list, it is. The only difference is the delivery mechanism.
Why the injected payload arrives after your own HTML
The loader is async. The config fetch is a second network round trip. Many tags defer execution to DOMContentLoaded, load, or an idle callback to protect Core Web Vitals. So the injection lands hundreds to thousands of milliseconds after your first byte.
That timing changes how you test:
curl https://yoursite.examplewill never show the payload.- View Source will never show it.
- A build-time dependency scanner will never show it.
- Browser caching means the poisoned container can keep serving after the vendor fixes their side, sometimes for hours. Whatever cache TTL your loader carries is your minimum exposure window after remediation.
I ran a small harness — a static page with one container loader and a synthetic config — to measure when injected nodes actually appear. PerformanceObserver output below is from that harness, not from any affected site:
late-script https://cdn.tagvendor.test/tags/pixel.js 2841
late-script https://cdn.tagvendor.test/tags/heatmap.js 2903
[script] <inline 412b> nonce=-
[iframe] https://cdn.tagvendor.test/frame/collect.html
Three seconds after navigation. That's the window your monitoring has to close.
Audit Step 1: Inventory Every Third-Party Origin You Actually Load
You cannot write a CSP, an allowlist, or a kill switch for origins you haven't enumerated. Most orgs I've looked at have a tag plan document that is wrong: it lists the tags marketing remembers, not the tags that fire on the checkout page in the EU under consent mode B.
Extracting script origins from real sessions, not the tag plan
Use a real browser and record what actually loads. Playwright is enough:
import { chromium } from "playwright";
const target = process.argv[2];
if (!target) throw new Error("usage: node script-inventory.mjs https://example.test/checkout");
const siteOrigin = new URL(target).origin;
const browser = await chromium.launch();
const page = await browser.newPage();
const seen = new Map();
page.on("request", (req) => {
let url;
try { url = new URL(req.url()); } catch { return; }
if (url.protocol !== "https:" || url.origin === siteOrigin) return;
const rec = seen.get(url.origin) ?? { origin: url.origin, count: 0, types: new Set(), paths: new Set() };
rec.count += 1;
rec.types.add(req.resourceType());
rec.paths.add(url.pathname);
seen.set(url.origin, rec);
});
await page.goto(target, { waitUntil: "networkidle" });
await page.waitForTimeout(6000); // let idle/deferred tags fire
for (const rec of [...seen.values()].sort((a, b) => b.count - a.count)) {
console.log(JSON.stringify({
origin: rec.origin,
requests: rec.count,
types: [...rec.types],
sample: [...rec.paths].slice(0, 2),
}));
}
await browser.close();Run it per template — home, product, checkout, account settings, a logged-in dashboard — and more than once. Consent banners, geo, and A/B assignment change the set.
Observed output on the harness, trimmed:
{"origin":"https://cdn.tagvendor.test","requests":9,"types":["script","xhr"],"sample":["/container/v3/a1b2c3d4.js","/config/a1b2c3d4.json"]}
{"origin":"https://fonts.example-cdn.test","requests":4,"types":["font","stylesheet"],"sample":["/s/inter/v18.woff2"]}
{"origin":"https://pixel.ads.test","requests":3,"types":["image","script"],"sample":["/px.gif","/tag.js"]}
{"origin":"https://collect.session.replay.test","requests":2,"types":["script","fetch"],"sample":["/rec.js"]}
Nine requests to one origin, and only one is the loader people know about. The config fetch and the tag scripts are the interesting ones.
Attributing each origin to an owner and a business justification
An origin inventory without an owner is a list, not a control. Force four columns:
| Origin | Purpose | Owner (team + person) | Kill switch tested? |
|---|---|---|---|
| cdn.tagvendor.test | Container + all marketing tags | Growth / @name | Yes, CSP block in staging |
| pixel.ads.test | Paid media conversion | Paid media / @name | No |
| collect.session.replay.test | Session replay | Product analytics / @name | Yes |
My rule: if nobody will put their name on the origin, it gets deleted in the next sprint, not documented. Unattributed third-party script is liability with an unknown revenue argument.
First-Hour Triage Runbook for a Suspicious Tag Vendor Breach
Assume you've just read the news and your vendor is named in it. Do these four things in order.
Snapshot and diff the container configuration
The loader fetches the container config over HTTP, so you can fetch it too. Snapshot before anything changes, then diff against a known-good copy.
CONTAINER="https://cdn.tagvendor.test/config/a1b2c3d4.json"
curl -sS --max-time 15 "$CONTAINER" -o "container-$(date -u +%Y%m%dT%H%MZ).json"
shasum -a 256 container-*.json
The diff is where you learn the most. Container schemas differ per vendor, so this snippet is from my synthetic container, not Optimizely:
--- container-20261117T0900Z.json
+++ container-20261117T1100Z.json
@@
- { "tag_id": 41, "type": "ga4_event", "enabled": true }
+ { "tag_id": 41, "type": "ga4_event", "enabled": true },
+ { "tag_id": 77, "type": "custom_html", "enabled": true,
+ "html": "<script src=\"https://cdn.tagvendor.test/u/9f2.js\"></script>" }
A custom_html tag enabled outside a change window is the highest-signal finding in this runbook. Look for new custom HTML tags, changed tag URLs, new triggers that fire on all pages, and new "consent override" flags.
Probe the live DOM for unexpected script and iframe nodes
Static analysis of the config misses anything the loader builds at runtime. Watch the DOM instead:
// Paste in DevTools console, or run via page.evaluate in Playwright.
const report = (node) => {
if (node.nodeType !== 1) return;
const tag = node.tagName.toLowerCase();
if (tag === "script") {
console.log("[script]", node.src || `<inline ${node.textContent.length}b>`, "nonce=", node.nonce || "-");
}
if (tag === "iframe") {
console.log("[iframe]", node.src, "sandbox=", node.getAttribute("sandbox") ?? "none");
}
};
new MutationObserver((muts) => muts.forEach((m) => m.addedNodes.forEach(report)))
.observe(document.documentElement, { childList: true, subtree: true });
new PerformanceObserver((list) => {
for (const e of list.getEntries()) {
if (e.initiatorType === "script" && !e.name.startsWith(location.origin)) {
console.log("late-script", e.name, Math.round(e.startTime));
}
}
}).observe({ type: "resource", buffered: true });
Run this on a logged-in session on a sensitive template, not the homepage. The homepage is the page you've tested a hundred times; checkout is where injected code is worth the most.
Verify the loader bytes against a pinned hash
Compute the hash of what the CDN is serving right now and compare it to the loader you reviewed:
URL="https://cdn.tagvendor.test/container/v3/a1b2c3d4.js"
curl -sS --max-time 10 "$URL" | shasum -a 384
curl -sSI --max-time 10 "$URL" | grep -iE 'cache-control|etag|content-type|last-modified'
Observed:
f3a91c2e5d7b04a8c1e6... -
cache-control: public, max-age=1800
content-type: application/javascript
etag: "5f1c9a"
Two things to note. max-age=1800 means a poisoned response sticks in browser caches for thirty minutes after the vendor fixes it. An etag is a weak signal — compare bytes, not headers.
This check tells you whether the loader matches your reviewed copy. It does not tell you whether the config that loader fetches is sane. Those are separate questions, and only the diff answers the second one.
Reading the results without overreading them
The failure mode in hour one is shouting about a false positive. Things that legitimately produce new origins and new script nodes:
- an A/B test or feature flag you didn't know shipped
- consent-gated tags firing because your consent test session chose "accept all"
- a vendor rotating their CDN hostname, which changes the origin but not the trust
- regional routing that serves a different edge host
- a new campaign landing page with its own container version
The signal that should move you to action is a combination: a new origin, a new custom-HTML tag, execution on authenticated templates, and a certificate or domain registered recently. Any one alone is weak. All four is an incident.
Benign Tag Behavior vs Injected Malware: A Triage Table
Use this to triage what the DOM probe produced. Nothing here is proof on its own.
| Observation | Weak signal | Strong signal |
|---|---|---|
| New script origin | Known CDN with a new subdomain | Domain registered recently, or a lookalike of a known vendor |
| Inline script | Vendor bootstrap with a version banner | atob/eval chain, long hex strings, String.fromCharCode arrays |
| Script attributes | async, defer, data-* config | nonce absent while the rest of the page is nonced |
| iframes | Sandboxed, known collector | Unparented iframe to an origin with no inventory entry |
| Cookie access | Reads its own first-party cookie | Reads unrelated cookies and immediately POSTs |
| Network shape | POST to the vendor origin | POST to an origin the page never contacted before, with a credentials: "include" fetch |
| Timing | Fires on load with other tags | Fires only for a subset of users or geos — targeted payloads |
| Persistence | None | serviceWorker.register(), pushState rewrites, click handlers on links |
The last row matters most. A payload that registers a service worker outlives the vendor fix, because the worker keeps intercepting requests from cache after you remove the snippet. If you see a service worker registration you didn't ship, treat it as a separate cleanup problem.
Control 1: A CSP That Survives a Tag Manager
Start in report-only, then enforce
Start report-only, always. You need the baseline before you can tell a legacy break from a real violation.
Content-Security-Policy-Report-Only: default-src 'self'; script-src 'nonce-{RANDOM}' 'strict-dynamic' https: 'report-sample'; object-src 'none'; base-uri 'none'; report-to csp-endpoint
Report-To: {"group":"csp-endpoint","max_age":86400,"endpoints":[{"url":"https://report.yoursite.example/csp"}]}
The nonce must be per response and unpredictable. Reports arrive as JSON:
{"type":"csp-violation","body":{"document-uri":"https://shop.example.test/checkout",
"blocked-uri":"https://cdn.tagvendor.test/u/9f2.js","violated-directive":"script-src-elem",
"effective-directive":"script-src-elem","disposition":"report"}}
I like script-src-elem violations because they name the injected script URL. That's your highest-value telemetry during a third-party incident.
strict-dynamic is where tag manager CSP quietly stops working
Here is where I'd push back on most CSP rollouts I see.
When 'strict-dynamic' is present, CSP3 browsers ignore host allowlists and 'self' in script-src. Trust propagates from a nonced script to every script that script injects. That is exactly what tag managers need to function, and exactly why CSP stops being your policy.
If you nonce the container loader and enable strict-dynamic, you've written a policy that says: the vendor may load anything it wants, forever, from any origin. You haven't restricted the blast radius. You've documented it.
That's not a reason to skip CSP. It's a reason to stop treating CSP as the control that saves you here. Two things actually help:
Segment by route. Serve a strict CSP with no tag manager at all on authentication, account settings, checkout review, and admin surfaces. Marketing tags don't need to run on /account/security. This is the highest-value change in this post, and it's boring enough that people skip it.
Constrain what injected code can reach. connect-src limits which origins a fetch can target, and form-action limits where forms can post. A payload can still exfiltrate through img.src in many configurations, but you raise the cost and generate violations when they try.
Trusted Types (require-trusted-types-for 'script') is worth adding, but be honest about scope. It blocks string-to-code sinks like innerHTML and eval, which kills a lot of injected one-liners. It does not stop a script that is already executing from calling trustedTypes.createPolicy() itself, unless you constrain policy names with the trusted-types directive. It's a speed bump on the payload, not a wall around the vendor.
Nonce propagation into the container
Under strict-dynamic, injected <script> elements don't need your nonce; propagation handles them. Under a non-strict-dynamic CSP, they absolutely do, and a static container config has no idea what nonce your server generated for this response.
The practical path is a global the loader can read:
// Inline, server-rendered, nonced — runs before the loader.
window.__cspNonce = document.currentScript.nonce;
Then verify empirically whether your container picks it up: count nonced versus non-nonced injected scripts in the DOM probe above. Some tag managers propagate a nonce for their own tags; third-party tag templates usually don't. I wouldn't assume either behavior. Measure it per container version, and re-measure after every vendor update.
Control 2: SRI and Its Honest Limits
What SRI protects and what it cannot
integrity on a script tag verifies the response bytes against a hash before execution. For a tag manager, that only works if two conditions hold:
- The loader URL is immutable and versioned. If the URL serves different bytes over time, a pinned hash breaks your site the moment the vendor deploys.
- The resource is CORS-enabled. Cross-origin SRI requires the server to return
Access-Control-Allow-Origin; otherwise the browser can't verify and the load is blocked.
<script
src="https://cdn.tagvendor.test/container/v3/a1b2c3d4.1719.js"
integrity="sha384-REPLACE_WITH_REAL_HASH"
crossorigin="anonymous"
async></script>
What SRI cannot do, and this part gets oversold:
- It cannot cover script URLs that only exist in the fetched config. Your HTML never contains those tags, so there is no
integrityattribute to check. - It cannot cover inline custom-HTML tags. No URL, no hash.
- It cannot cover the config JSON itself.
- It cannot stop a pinned, unmodified loader from being told by a poisoned config to inject anything it likes.
That last point is the whole ballgame. SRI on a tag manager is change detection, not an authorization control. It proves the loader wasn't swapped. It proves nothing about what the loader was told to do. If your incident response plan says "we have SRI on the tag manager, so we're covered," the plan is wrong.
Pinning the container loader and alerting on hash drift
SRI is weak as a control, so use hashing for what it's actually good at: detection. A cron job that compares the live loader to a pinned hash tells you about a swap within minutes, and it works even where you can't ship integrity attributes.
#!/usr/bin/env bash
set -euo pipefail
URL="https://cdn.tagvendor.test/container/v3/a1b2c3d4.js"
PINNED_FILE=".pinned/container-a1b2c3d4.sha384"
NOW=$(curl -sS --max-time 10 "$URL" | shasum -a 384 | cut -d' ' -f1)
PINNED=$(cut -d' ' -f1 "$PINNED_FILE")
if [ "$NOW" != "$PINNED" ]; then
echo "DRIFT url=$URL pinned=$PINNED observed=$NOW" >&2
exit 2
fi
echo "ok $NOW"Observed on a simulated vendor deployment:
DRIFT url=https://cdn.tagvendor.test/container/v3/a1b2c3d4.js pinned=f3a91c2e5d7b04a8c1e6... observed=8c04be17aa2d9930f5b1...
exit code: 2
Route that to the same alert channel as your deploy failures, not to a marketing Slack. It's a security alert and should page the same way.
Control 3: Allowlisting and Egress Restrictions for Tag Payloads
Allowlisting is where CSP and browser behavior collide, so be specific about the surface you're allowlisting:
| Surface | Control | Honest limitation |
|---|---|---|
| Routes with no tag manager | script-src 'nonce-…' 'strict-dynamic' | Needs the route to genuinely not load the container |
connect-src | Explicit origin list | Exfil via image beacons still possible in some setups |
| Service workers | worker-src 'self' | Blocks vendor workers you might actually want |
| iframes | frame-src allowlist + sandbox on vendor frames | Vendor frames that need same-origin access break |
| Server-side tagging | Egress allowlist on the proxy | Only protects the server leg, not the browser leg |
| DNS | Allowlist for the tag proxy zone | Operational cost; needs an owner per record |
The trap: if the container loader is allowed to inject dynamically, a script-src allowlist for other vendors is decorative. Injected code from the container can add a script tag whose URL you never allowlisted, because the trust came from the loader, not the list. Allowlisting works on routes where the container is absent, and it works for connect-src. It does not substitute for removing the container.
Monitoring Third-Party Script Loads to Shorten the Detection Window
Client-side script-origin telemetry from the RUM layer
CSP reports only fire when you're already enforcing or in report-only. Add a cheap independent signal: report every non-first-party script origin seen in a session.
const firstParty = location.origin;
const seen = new Set(
performance.getEntriesByType("resource")
.filter((e) => e.initiatorType === "script")
.map((e) => { try { return new URL(e.name).origin; } catch { return null; } })
.filter((o) => o && o !== firstParty)
);
navigator.sendBeacon("/__rum/script-origins", JSON.stringify({
path: location.pathname,
origins: [...seen],
ts: Date.now(),
}));
Aggregate daily and diff against the inventory. Output from the harness, aggregated by route:
/checkout cdn.tagvendor.test pixel.ads.test collect.session.replay.test
/account/* collect.session.replay.test
/ cdn.tagvendor.test fonts.example-cdn.test
A new origin under /checkout on a Tuesday is worth a page. A new origin under /account/* — a route that shouldn't load any third party — is worth waking someone up.
Origin and certificate change alerts
Payload hosting often moves before the loader does. Watch:
- Certificate Transparency logs for new certificates on vendor-adjacent domains. A new cert on a lookalike domain that appears in your container config is a strong signal.
- DNS change detection on origins in your inventory — new A records, new nameservers.
- TLS issuer/expiry changes at the edge for origins you depend on.
- Domain registration age for any new origin in the inventory. Anything registered in the last 90 days gets extra scrutiny by default.
None of this is exotic. The reason it doesn't exist in most orgs is that nobody owns third-party origins as an asset class. That ownership gap is the vulnerability.
Isolation Playbook: Cutting a Vendor Off in Minutes
Order of operations: CSP block first, cache purge last
- Flip the edge header to block the vendor origin. If you have header rules at a CDN or edge worker, this is minutes and doesn't need a deploy.
script-srcwith the vendor origin removed (orframe-src 'none'if the injection is iframe-based) stops new infections immediately. - Capture evidence — see the next subsection. Do this before you purge anything.
- Remove the snippet from templates and redeploy.
- Purge CDN and browser caches for the loader path, and drop the
max-ageon the loader to something short going forward. A 1800-second TTL is a 30-minute tail on every remediation. - Check for persistence. Service workers registered by an injected script,
pushStatehandlers, injected<base>tags. Unregister workers and ship a no-op replacement. - Treat credentials as exposed. Any session cookie readable by JavaScript on an affected page should be rotated. Moving session cookies to
HttpOnlyis a follow-up that should have happened years ago. - Notify — security, legal, and your account team at the vendor. Get the container's clean version confirmed in writing, with a hash.
- Re-enable in report-only first, watch for the vendor origin reappearing, then enforce.
Preserve evidence before you purge
Purging the CDN can destroy the only copy of what was actually served, because the vendor may have already rotated their config. Save, with UTC timestamps:
- Full HAR export with response bodies from a browser that loaded the page during the window
- The container config JSON and its SHA-256
- The loader bytes and their SHA-384
- CSP reports for the window
- A DOM snapshot showing injected nodes
- Which user cohorts and regions hit it (from RUM, not from memory)
Blocking first and capturing second is safe because blocking at the edge changes your headers, not the vendor's served bytes. Purging first is not safe. Get the ordering right.
What I Would Fix First, in Order
Ranked, with reasoning:
- The inventory and the kill switch. You cannot respond in minutes to a vendor you didn't know you were loading. Every origin gets an owner and a tested kill switch this quarter. This beats CSP because it's a prerequisite for writing a CSP that means anything.
- Route segmentation. Get the tag manager off authentication, account settings, and payment review. This is the single change that bounds the damage of the next incident regardless of what the vendor does.
- Short cache TTLs and pinned container versions. Your exposure window after a vendor fix is your cache TTL. Make it small, and know which version you're on.
- CSP in report-only, then enforce where the container isn't. Start with the routes from step 2, where enforcement is achievable. Don't pretend a
strict-dynamicpolicy on marketing pages is a control. - Hash drift alerting on the loader. Cheap, catches the swap case, and gives you a timestamp to anchor an investigation.
- SRI where the loader URL is immutable. Do it, but file it under detection, not prevention.
I'd explicitly not start with a full-site CSP rollout. It takes months, it ends in a strict-dynamic policy that delegates everything to the vendor, and you'll have spent the time without reducing blast radius.
What I Confirmed and What I Did Not Test
Confirmed — from primary sources or my own runs:
- The November 17, 2026 reporting states that an Optimizely vulnerability was exploited to inject malware into customer sites, that 178 organisations were affected, and that coverage links the campaign to cryptocurrency theft.
- The inventory script, DOM mutation observer,
PerformanceObservertiming, hash checks, and drift check above ran against a local harness I built; the outputs shown are from that harness. - CSP
'strict-dynamic'causes host-source allowlists to be ignored in CSP3 browsers, and SRI requires CORS for cross-origin resources. Both are spec behavior, per W3C CSP3 and the SRI spec. require-trusted-types-for 'script'constrains DOM XSS sinks and is not a boundary against an already-executing third-party script.
Not tested / not established:
- Which Optimizely component was vulnerable, and whether the injection path was a server-side flaw, an account compromise, or a container-config write. The public coverage I read does not say.
- The actual payload's behavior — wallet draining, cryptomining, or redirect — beyond the reported link to cryptocurrency theft.
- Whether Optimizely's container propagates a CSP nonce to injected tags. I did not test their product; I described how to measure it.
- Any browser-specific behavior differences beyond the CSP3 and SRI spec statements above.
- Whether any specific affected site had the controls in this post. I have no visibility into that.
Further Reading
- SecurityWeek — Optimizely Vulnerability Exploited to Serve Malware on Major Websites — reporting on the incident and affected count
- Nine.com.au — Optimizely hack: cyberattack targets popular websites, aims to steal cryptocurrency — coverage of the cryptocurrency-theft link
- fish4news.co.uk — Optimizely cyberattack exposes visitors to malware on 178 organisations' websites — affected-organisation count
- WDIV ClickOnDetroit — Cyberattack targets Optimizely, third-party software used by major websites — context on the third-party software angle
- MDN — Content-Security-Policy — directive reference, including
script-src,strict-dynamic, andreport-to - W3C — Content Security Policy Level 3 — normative behavior for strict-dynamic and host-source handling
- MDN — Subresource Integrity — hash algorithm support and the CORS requirement
- W3C — Subresource Integrity — the specification itself
- MDN — ReportingObserver — capturing CSP and deprecation reports client-side
- OWASP — Content Security Policy Cheat Sheet — practical deployment guidance
- MDN — Trusted Types — what
require-trusted-types-fordoes and does not cover
More posts

Dissecting a Fake Security Scanner Repo: postinstall Hooks, Obfuscated Loaders, and Exfil Endpoints
A repo-level teardown of a fake GitHub "security scanner" that chains a postinstall hook, an obfuscated loader, and an exfiltration endpoint into a developer-targeted backdoor, with the install-script and CI controls that expose it before it runs.

Testing CSP, Script Allowlists, and Vendor Isolation Against a Compromised Third-Party Script
A hands-on walkthrough of how the Optimizely supply-chain compromise pushed malicious code onto CNN, Fox News, BBC, and Salesforce, and how to test CSP, SRI, script allowlists, and vendor isolation against a hostile third-party script.

Scaling Agents on Kubernetes with acpx and ACP: Isolation, Routing, and Cost per Agent
A deep technical walkthrough of how acpx and ACP package agent runtimes on Kubernetes, covering where agent state and tool routing live, how to reason about horizontal scaling and per-agent isolation, and how to model cost per concurrent agent.
Loading comments…