Safeguard
Supply Chain Security•

Optimizely Web Compromise: How a Trusted Script Turned Malicious

On 16 November 2026 malicious JavaScript was added to Optimizely Web customer projects and served from Optimizely's own CDN. What happened, why a trusted third party script can turn hostile with no breach of your own systems, and the CSP, integrity, monitoring and access controls that limit the damage.

Safeguard Security Team
57 min read

On 16 November 2026, an attacker added malicious JavaScript to the Project JavaScript of Optimizely Web customer projects, and Optimizely's own delivery network then served that code to visitors of those customers' websites. Optimizely says an unauthorized party "exploited a vulnerability in Experimentation" to do it, and that it has fixed the vulnerability, removed the injected code and secured affected user accounts. Report URI, the researchers who published the first detailed account, report 188 infected snippets belonging to 178 organisations, and a payload that swapped cryptocurrency wallet addresses, skimmed card details typed into page forms, sent cookies and screenshots to the attacker, and loaded iPhone exploit kits on older iOS versions. None of the affected sites had to be breached for this to happen. They had allowed a trusted vendor's script to run on their pages, and that script changed.

Below: what was reported and by whom, then why a trusted content delivery network (CDN) script can turn malicious, where Content Security Policy (CSP) helps, why Subresource Integrity (SRI) does not fit dynamic vendor snippets, and the response steps that shrink the damage.

Key takeaways

  • Optimizely confirms the core facts. Its status page entry, posted at 01:02 UTC on 17 November 2026, says an unauthorized party exploited a vulnerability in Experimentation to add malicious JavaScript to some customer projects, and that the vulnerability is fixed and the code removed.
  • The scale figures come from Report URI. Report URI reports that it checked 1,611 Optimizely snippets and found 188 infected snippets belonging to 178 organisations, and says the real number is likely higher. Optimizely has not published a count.
  • The CDN was not poisoned. Report URI says Optimizely's CDN "served exactly what it was given". The malicious code sat inside a field that customers use for their own code, so it was delivered as part of a legitimate, allowed file.
  • Allowing the vendor host in CSP did not help. Report URI crawled 256 of the affected organisations' own hosts and reports that only 24 blocked the payload. What stopped it was a restrictive script-src without 'strict-dynamic' or 'unsafe-eval', plus tight connect-src to stop data leaving.
  • SRI cannot pin a file that is meant to change. An experimentation snippet is rebuilt whenever a test changes. An integrity hash on it either breaks your experiments or gets turned off.
  • Act on your own side now. Review Project JavaScript and experiment code, rotate exposed tokens and cookies, scope card and session exposure for 16 November, move CSP from report only to enforce, and put change monitoring on every third party script you load.

What happened?

Optimizely Web (also sold as Optimizely Web Experimentation) is an A/B testing and personalisation product. A site adds one script tag, the snippet, and that file carries Optimizely's client code, the site's experiments, and an optional field called Project JavaScript. Optimizely's documentation describes Project JavaScript as "the first point of execution in the snippet" that "can potentially affect all experiments" (Optimizely docs). Report URI calls it "custom code the customer writes in their Optimizely dashboard, which runs on every page" (Report URI).

According to Report URI, the attacker wrote a small loader into the Project JavaScript of many unrelated customer projects and left the rest of each snippet unchanged. Every visitor to an affected page then downloaded the snippet from Optimizely's CDN, ran the loader, and pulled a second stage script, track.js, from the attacker's domain 1688360.cc (Report URI).

Optimizely's own account is short. Its status page says: "Earlier today, Optimizely identified a security incident in which an unauthorized party exploited a vulnerability in Experimentation and used it to add malicious JavaScript to some customer projects. We've fixed the vulnerability and removed the injected code from affected projects. We've also taken steps to secure affected user accounts and put additional protections in place to prevent unauthorized code from being delivered." The entry is titled "Web Experimentation Security Incident", lists the Snippet Delivery component, and was in Monitoring status when we read it at 02:12 UTC on 17 November 2026 (Optimizely status). Optimizely has not published a postmortem, a count of affected projects, or details of the vulnerability.

A second, independent write-up by the Hudson Rock research team on infostealers.com says it directly recovered eight poisoned Optimizely project files between about 21:00 and 21:29 UTC on 16 November and analysed the embedded payload statically. It describes its iOS observations as delivery observations, not demonstrated device compromises, and says the number of malicious page loads, successful thefts and compromised devices "remains unknown".

How the injected code reached visitorsThe visitor loads your page, your page loads the Optimizely snippet from Optimizely, the attacker loader sits inside the Project JavaScript part of that snippet, and it pulls track.js from 1688360.cc, which sends card data, cookies and screenshots back to the same host.How the injected code reached visitorsOptimizely Web, 16 November 2026, as described by Report URIVisitor's browserloads your pageYour pagescript tag for theOptimizely snippetSnippet file from Optimizelycdn.optimizely.com/js/ID.jsOptimizely client codeYour experimentsProject JavaScriptattacker loader added here;rest of the file unchangedAttacker server1688360.cc/track.jswallet address swap,card skimmer, cookies,screenshots, iOS kitsData sent out1688360.cc/card.php1688360.cc/hit.phpfrom the visitor browserReport URI: the CDN served exactly what it was given; this was not cache poisoning. Self hosted copies ofthe snippet were affected too, because the content comes from the same Optimizely project.
Figure 1. The load chain Report URI describes: your page loads the vendor snippet, the injected loader in Project JavaScript fetches a second stage from the attacker's host, and stolen data goes back to that host.

Which organisations were affected?

Report URI's post names a number of household brands across banking, media, travel, retail and software. Optimizely has not named affected customers, and at the time of writing we have not seen those companies confirm it themselves, so this post refers to them as organisations using Optimizely Web. Report URI's sector breakdown, by number of organisations, is led by banking and finance (32), technology and SaaS (23), retail and fashion (20), streaming and entertainment (12) and news and media (10), with smaller counts in travel, healthcare, manufacturing, telecoms, crypto and trading, insurance and other sectors (Report URI). If you run Optimizely Web, assume you need to check rather than wait to be told.

Report URI also notes that customers who serve the snippet from their own domain were affected: "Those were affected too, because the content comes from the same Optimizely project." Self hosting changes where the file is served from, not who writes its contents.

How did the attacker get in?

Optimizely says the attacker "exploited a vulnerability in Experimentation" (Optimizely status). It has not said what the vulnerability was, when it was introduced, or how long it was exploitable. Report URI's post, written before Optimizely's statement, says "We don't know how the attacker got write access to so many unrelated customer projects" (Report URI). Treat any more specific explanation you read elsewhere as speculation until Optimizely publishes one.

That detail matters for defence. If the entry point was a flaw on the vendor side, strong passwords and multi factor authentication on your own Optimizely accounts would not have stopped it. They still matter, because Optimizely also says it took "steps to secure affected user accounts", and because the next incident may come through a stolen customer credential instead. But the controls that limit damage from a vendor side flaw live in the browser and in your monitoring, not in the vendor's login page.

What did the malicious code do?

Everything in this section is as reported by Report URI, unless another source is named. Report URI says the payload was rebuilt 26 times during the day (Report URI).

Three loader variants

Report URI saw three versions of the injected loader:

  1. A plain script tag pointing at https://1688360.cc/track.js, in most snippets.
  2. The same URL hidden in base64 and decoded with atob(), so "a search for '1688360.cc' won't find it".
  3. A full inline copy of the payload, which "runs through eval if 1688360.cc is blocked".

The third variant is the important one for defenders. It means blocking the attacker's domain alone does not stop the code from running in the page. Report URI says this fallback needs 'unsafe-eval' or 'unsafe-inline' in the page's policy, so only a policy that refuses both stops that path.

Cryptocurrency address swapping

The payload replaced wallet addresses for Bitcoin, Ethereum and other EVM chains, TRON, Solana, TON, Litecoin, Bitcoin Cash and Dogecoin with attacker addresses. Report URI says the swap applied to page content, forms, the clipboard, outgoing requests and the iOS share sheet. As of 19:25 UTC on 16 November, Report URI counted about $7,040 received by the attacker wallets, swept out to exchanges between 13:03 and 13:05 UTC. Report URI also says the TRON wallet had been in use since March 2026.

Address swapping is worth singling out because it needs no network call to do harm. The visitor copies an address, the page hands them a different one, and the visitor sends the funds themselves. A policy that blocks data leaving the page does not prevent this.

Card skimming

From 13:43 UTC, Report URI says, track.js also captured card number, expiry and CVV from forms and POST requests and sent them to 1688360.cc/card.php. Report URI notes that cards entered in hosted payment iframes were out of reach. It does not know how many cards were captured.

Cookie and screenshot theft

When it swapped an address next to wallet or payment wording, Report URI says, the payload sent the page URL, cookies not marked HttpOnly, the original addresses it replaced, and a screenshot made with the html2canvas library to 1688360.cc/hit.php (Report URI). Any session token or other secret kept in a cookie that page script can read should be treated as exposed for affected sites on that day.

iOS exploit kits

On iPhones and iPads, Report URI says the payload loaded a router script from a separate set of .icu domains, which then ran one of two known exploit kits depending on the iOS version: Coruna for iOS 13 to 17, and DarkSword for iOS 18.x, with only device fingerprinting for iOS 26. Google's Threat Intelligence Group has documented both kits. It describes Coruna as five full iOS exploit chains made up of 23 exploits, effective against iOS 13.0 through 17.2.1 and "not effective against the latest version of iOS". It describes DarkSword as a full chain of six vulnerabilities supporting iOS 18.4 through 18.7, with the last fixes in iOS 26.3 and earlier fixes in releases such as iOS 18.7.3. Report URI says the kit's own comments name iOS 18.7.3 and later, and 26.3 and later, as patched. Hudson Rock stresses that these are delivery observations, not demonstrated compromises (Hudson Rock).

Indicators of compromise

Report URI published indicators of compromise (IOCs). The core network indicators are below. Block each domain together with its subdomains, and search your own logs, CSP reports and archived pages for them.

1688360.cc            C2 for track.js, card.php, hit.php, html2canvas.min.js
5vobauua3ojpklx.icu   iOS router (boot.js)
eil786npto9u5bq.icu   iOS router, Coruna, iOS 26 pages
l7bcsnwc7nzr3uo.icu   Coruna telemetry (POST /api/iptj)
webshell.lol          injector get.js (earlier wave)
linkforge.cc          SEO panel script carrying the injector
je4ft3gn8vxudum.icu   fallback C2 in boot.js
q1ls1ho9x7wsxlu.icu   fallback C2 in boot.js
ios-hack.icu          fallback C2 in boot.js

Page markers:  window._k7, window.__k7b, data-channel-code="02111110"
track.js SHA-256 (17:13 build):
  814a963c0da480e2449d9b6664480156e1cd6d731014117401bf635badec3a0f
track.js SHA-256 (17:57 build):
  f7b84b9a94f749f8ced3f0112d0a66894e8bbc3b4aa5592021d1b8976a9bad40

Report URI's post also lists the IP addresses, related domains on the same certificates, and the attacker wallet addresses. Use the original list as the reference copy rather than this summary.

When did it happen?

All times are UTC on 16 November 2026 and come from Report URI's published timeline, except where Optimizely or Hudson Rock is named (Report URI).

Time (UTC)EventReported by
17 SepThe same actor's injector, webshell.lol, first appears on other sitesReport URI
9 Nov 17:52First iOS router domain registeredReport URI
13 to 16 NovEarlier wave injects webshell.lol/get.js through other vendors' scriptsReport URI
02:21Last clean capture of one affected Optimizely snippetReport URI
04:21First Optimizely injection observedReport URI
05:231688360.cc registered (certificates issued from 04:28)Report URI
08:10First build of track.jsReport URI
08:28track.js first seen on a live siteReport URI
13:03 to 13:05Stolen crypto swept to exchangesReport URI
13:43Card skimmer added to track.jsReport URI
16:38Second iOS router domain registeredReport URI
17:13 to 17:57Second iOS host added; Coruna iframe injectedReport URI
19:24 to 19:59Report URI sweep: 186 of 1,611 snippets infectedReport URI
about 20:40 to 21:10Mass cleanup of infected snippetsReport URI
21:00 to 21:29Poisoned files recovered for analysisHudson Rock
21:52One of 188 infected snippets still infectedReport URI
17 Nov 01:02Status page: vulnerability fixed, code removedOptimizely

Report URI's figures move during the day and do not all reconcile: 186 of 1,611 snippets infected at the 19:24 sweep, 169 still infected at 20:56, and 188 in total. We use 188 snippets and 178 organisations as its headline figures and read them as a floor, since Report URI says the real number is likely higher.

Timeline of 16 November 2026 in UTCFirst injection seen 04:21, track.js live 08:28, crypto swept 13:03, card skimmer added 13:43, iOS exploit iframe 17:13, Report URI sweep at 19:24 finds 186 of 1,611 snippets infected, cleanup from 20:41, one snippet left at 21:52, and Optimizely posts its status statement at 01:02 UTC on 17 November.16 November 2026, hour by hour (UTC)Times as published by Report URI; the last marker is Optimizely status page00:0004:0008:0012:0016:0020:0024:0004:21first injection seen08:28track.js live on a site13:03crypto swept out13:43card skimmer added17:13iOS exploit iframe added19:24sweep: 186 of 1,61120:41mass cleanup starts21:52one snippet left17 Nov 01:02Optimizely: vulnerabilityfixed, code removedReport URI also reports an earlier wave from 13 November through other vendor scripts and a payload rebuilt 26 times on the day.
Figure 2. The day in UTC, from Report URI's published timeline, with Optimizely's status page entry at 01:02 UTC on 17 November.

The shape of this timeline is typical of third party script attacks. The code was live for most of a working day across several time zones before mass cleanup began, and the attacker kept improving the payload while it was live, adding the card skimmer more than nine hours after the first injection. The first public account came from outside, from a researcher sweeping vendor snippets.

Why can a trusted CDN script turn malicious with no breach of your own systems?

Because your page trusts the vendor's file, not a specific version of it. When you add a third party script tag, you let whoever controls that file run code in your origin, with the same access to the page as your own code: the DOM, form fields, the cookies that page script can read, and the network. The browser cannot tell your code from the vendor's. Your servers, your source code and your build pipeline can all be untouched while the code running in your customers' browsers changes underneath you.

Three properties make experimentation and tag management tools a strong target for this:

  • They are designed to run arbitrary code. Changing a page without a deploy is the product. Project JavaScript, custom experiment code, and custom HTML or JavaScript tags in tag managers all exist so that people outside the engineering release process can ship code to production.
  • They run first and everywhere. Optimizely's documentation says Project JavaScript is the first point of execution in the snippet and can affect all experiments. Code there runs on every page view that loads the snippet, including checkout and login pages if the snippet is on them.
  • One vendor serves thousands of sites. A single flaw in the vendor's platform reaches every customer at once. Report URI's count, 178 organisations in one day, is what that multiplier looks like.

This is the browser side of the software supply chain. Most supply chain programmes focus on what goes into a build: open source packages, base images, build tools. Third party scripts never pass through your build. They are fetched at runtime from someone else's server, so the inventory, review and pinning you apply to dependencies do not reach them unless you extend them on purpose. The OWASP Third Party JavaScript Management Cheat Sheet and the OWASP Top 10 Client Side Security Risks project both describe this class of risk.

Did the earlier wave use the same technique?

Report URI says the same injector, webshell.lol/get.js, was injected between 13 and 16 November through scripts from other marketing and content vendors, and that it first appeared on other sites on 17 September (Report URI). Hudson Rock, using captures from an independent researcher whose hashes it corroborated, reports the earliest vendor response observation in that set at 05:42 UTC on 13 November, through a different vendor's script (Hudson Rock). If the reported links hold, this was one operator working through several third party script providers, not a one off. That is a reason to review every vendor script on sensitive pages, not just Optimizely.

Would Content Security Policy have stopped it?

Partly, and only if the policy was strict in specific ways. CSP is a response header that tells the browser which sources of script, connections, images, frames and form targets a page may use (MDN: CSP, W3C CSP Level 3). It cannot inspect what an allowed script does. It can only refuse the next resource that script asks for.

Report URI evaluated the CSP of 256 affected organisations' own hosts against what this payload needed and published four outcome groups (Report URI):

Outcome as reported by Report URICount
No CSP at all68
CSP allowed the payload and the data theft50
Payload ran, but connect-src blocked the data theft (address swapping still worked)17
Payload blocked24 (15%)

The four groups total 159, not 256, and Report URI's table labels the rows organisations while its text says it crawled hosts. The post does not explain the other 97, so read these as approximate proportions rather than a complete census.

What the CSPs of affected hosts did, as reported by Report URIBar chart: 68 hosts had no CSP, 50 had a CSP that allowed the payload and the data theft, 17 ran the payload but connect-src blocked the data theft, and 24 blocked the payload.What the CSPs of affected hosts did, as reported by Report URIReport URI crawled 256 hosts; the four groups it published total 159No CSP at all68CSP allowed payload and data theft50Payload ran, connect-src blocked theft17Payload blocked24Source: Report URI, 16 November 2026. Its table labels these organisations; its text says 256 hosts were crawled.
Figure 3. CSP outcomes across affected hosts, as published by Report URI. The four groups it published total 159 of 256 hosts crawled.

Report URI's conclusion is that "what separated the 24 protected sites from the rest was a restrictive script-src". It also explains why allowing the Optimizely host was never going to be enough: the malicious code came from that trusted host. Walk through the payload one step at a time and the picture is clear.

Where a Content Security Policy can and cannot stop this payloadStep one, the vendor snippet, always runs because the vendor host is allowed. Step two, loading track.js, is blocked by a host list without strict-dynamic. Step three, the eval fallback, is blocked without unsafe-eval. Step four, sending data out, is blocked by tight connect-src and img-src, though in-page address swapping still works.Where a Content Security Policy can and cannot stop this payloadEach step is a separate browser decision. The first one always passes for an allowed vendor.1 Snippet loads from Optimizelyscript-src allows the vendor hostRuns. Injected Project JavaScriptruns with it. CSP cannot help here.2 Loader requests 1688360.cc/track.jshost list without 'strict-dynamic'Blocked. With 'strict-dynamic' theinserted script inherits trust: runs.3 Fallback inline copy via evalno 'unsafe-eval' in script-srcBlocked. With 'unsafe-eval'the inline copy runs anyway.4 Sends cards, cookies, screenshotstight connect-src, img-srcBlocked. The in-page wallet addressswap still works without a network call.Based on the loader variants and CSP outcomes Report URI published, and on CSP Level 3 (W3C).
Figure 4. Each stage of the payload is a separate browser decision. The vendor file itself always runs; CSP can refuse the second stage, the eval fallback and the outbound requests.
  1. The snippet loads. Your script-src allows the Optimizely CDN, because it must for the product to work. The file runs, including the injected Project JavaScript. No CSP setting can stop code inside an allowed file.
  2. The loader adds a script from 1688360.cc. A host allowlist that names only your own origin and Optimizely's hosts refuses it. But if your policy uses 'strict-dynamic', the browser extends trust to scripts that an already trusted script inserts, and host allowlists are ignored in browsers that support it (MDN: script-src). Report URI puts it plainly: "any script the trusted Optimizely snippet inserts is trusted too."
  3. The fallback runs the payload through eval. Without 'unsafe-eval' in script-src, the browser refuses. With it, the inline copy runs even where track.js was blocked, as Report URI observed. Report URI lists 'unsafe-inline' as the other setting that lets this fallback through.
  4. The payload sends data out. A connect-src (and img-src, since images are a common beacon channel) limited to known endpoints refuses requests to 1688360.cc. Report URI's 17 sites in this group stopped the theft of cards, cookies and screenshots, but the wallet address swap still worked, because it happens inside the page.

Why do so many sites allow 'strict-dynamic' and 'unsafe-eval'?

Because vendor guidance and real constraints push them there. Optimizely's own CSP guidance offers a script-src that includes a nonce and 'strict-dynamic', and says that in browsers supporting 'strict-dynamic' "it is only necessary to apply the nonce value to the Optimizely Experimentation snippet script tag". It also says some features, including "audiences with custom JavaScript conditions", need 'unsafe-eval'. Report URI names both settings as ones that let this payload through.

'strict-dynamic' is a sound design for first party code. Google's strict CSP guidance recommends nonces with 'strict-dynamic' because host allowlists are easy to bypass and hard to maintain. The trade off is that you delegate trust: whatever a nonced script loads is trusted too. For your own bundles that is usually what you want. For a vendor snippet whose contents can change without your knowledge, it means the vendor's file decides what else runs on your page. In this incident, that delegation reached the attacker.

There is no free answer here. You can keep 'strict-dynamic' and accept that a compromised vendor file can load anything, or drop it and maintain an explicit host list, which carries its own bypass risks if any allowed host serves attacker controllable content. What you can always do is refuse 'unsafe-eval' unless a feature you have decided you need requires it, and keep connect-src, img-src and form-action narrow, because those limit damage whichever script-src model you choose.

A worked example: an enforce mode CSP for a page that uses an experimentation snippet

Below is an example policy for a storefront page that loads its own bundles and one experimentation snippet. It is a starting point to adapt, not a drop in header. Optimizely's documented hosts change by feature and account, so check its current CSP page before using any host below, replace the placeholders, and run it in report only mode first.

Content-Security-Policy:
  default-src 'none';
  script-src 'self' 'nonce-RANDOM_PER_RESPONSE' https://cdn.optimizely.com;
  script-src-attr 'none';
  style-src 'self' 'unsafe-inline' https://cdn.optimizely.com;
  img-src 'self' https://cdn.optimizely.com;
  font-src 'self';
  connect-src 'self' https://logx.optimizely.com https://api.example-payments.com;
  frame-src https://aACCOUNT_ID.cdn.optimizely.com https://js.example-payments.com;
  form-action 'self';
  base-uri 'none';
  object-src 'none';
  frame-ancestors 'self';
  upgrade-insecure-requests;
  report-to csp-endpoint
Reporting-Endpoints: csp-endpoint="https://csp-reports.example.com/r"

What each line is doing, and why:

  • default-src 'none' starts from nothing, so any resource type you forget to list is refused rather than allowed.
  • script-src lists your own origin, a nonce for your own inline bootstrap, and the vendor's exact CDN host. There is no 'strict-dynamic', so a script that the vendor file inserts from a new domain such as 1688360.cc is refused. There is no 'unsafe-eval', so the eval fallback is refused. There is no wildcard such as https://*.optimizely.com, because a wildcard allows every subdomain, including ones you never use.
  • script-src-attr 'none' blocks inline event handler attributes, a common injection path.
  • style-src includes 'unsafe-inline' because Optimizely's guidance says its style rule is required for experiment CSS to apply. Inline styles carry far less risk than inline script; drop it if you do not run CSS experiments.
  • img-src and connect-src are where data theft is decided. Only the endpoints your page actually calls are listed: your own origin, the vendor's event endpoint (logx.optimizely.com in Optimizely's guidance), and your payment provider's API. Requests to card.php or hit.php on any other host are refused.
  • frame-src allows the vendor's account specific frame host from Optimizely's guidance and your payment provider's hosted fields. Card entry inside that iframe is out of reach of page script, which Report URI noted for this payload.
  • form-action 'self' stops a script from re-pointing your forms at another host.
  • base-uri 'none' and object-src 'none' close two old bypasses.
  • report-to sends violation reports to your endpoint (MDN: report-to). Reports are your early warning: a sudden burst of blocked requests to an unknown host from many visitors is exactly what this incident would have produced on a protected site.

What this policy costs you:

  • Optimizely features that need 'unsafe-eval', such as audiences with custom JavaScript conditions, will not work. Decide whether you need them on sensitive pages; many teams keep experiments off checkout and login entirely.
  • This example lists only the snippet host in script-src. Optimizely's own guidance uses https://*.optimizely.com plus two Amazon S3 hosts, which it says serve the preview mode client and geotargeting. With the policy above those features will break until you add the exact hosts your report only run shows them loading from. The same applies to connect-src: the guidance adds https://*.optimizely.com alongside logx.optimizely.com, so expect to add specific Optimizely hosts there too.
  • The frame-src entry is only for cross domain behavioural targeting; drop it if you do not use that. If PCI mode is enabled on your account, Optimizely lists a second cdn-pci frame host.
  • Optimizely's CSP guidance lists extra hosts for its new Visual Editor. Use a separate, looser policy on an internal preview environment rather than loosening production.
  • Optimizely also says not to use require-trusted-types-for 'script', because experiments cannot apply changes with it (Optimizely CSP guidance). Trusted Types are worth adopting on pages that do not load such vendors.
  • If the vendor ever needs a script from a new host, the page will break until you update the policy. That is the point. Every new host becomes a change you review.

How do you move from report only to enforce?

Run the same policy in the Content-Security-Policy-Report-Only header first (MDN), as Optimizely's guidance also recommends. Collect reports for at least one full business cycle so you see campaigns and every experiment variation. Fix legitimate violations with exact hosts or by moving inline code into files, never with wildcards or 'unsafe-eval'. Then switch to Content-Security-Policy on checkout, login, account and payment pages first, keeping a report only header alongside for rules you want to trial next. Report only mode stops nothing; the 24 sites that blocked the payload and the 17 that stopped the theft were enforcing.

Would Subresource Integrity have stopped it?

Not for this kind of script, and it is worth understanding why before someone proposes it. SRI lets you add an integrity attribute with a cryptographic hash to a script tag. The browser fetches the file, hashes it, and refuses to run it if the hash does not match (W3C SRI, MDN SRI).

<script src="https://cdn.example.com/lib/4.2.1/lib.min.js"
        integrity="sha384-BASE64_HASH_OF_THE_EXACT_FILE"
        crossorigin="anonymous"></script>

That is excellent for a versioned library file that never changes. It does not fit an experimentation snippet:

  • The file is meant to change. The snippet contains your experiments and Project JavaScript. Every time someone launches, pauses or edits a test, the file changes and its hash changes. A pinned hash would break your experiments on the next edit, so in practice teams do not pin it.
  • A hash pins whatever was there when you computed it. If you computed the hash from a file that already contained injected code, SRI would faithfully protect the malicious version.
  • SRI covers only the tag that carries it. Scripts the vendor file inserts at runtime have no integrity attribute unless the vendor adds one.
  • Self hosting does not solve it alone. Report URI says self hosted snippets were affected, because they are copies of the same project content.

Where SRI does help is the rest of your third party list. Analytics libraries, UI widgets and polyfills loaded from public CDNs at fixed versions should carry integrity hashes. And there is a middle path for dynamic vendors that some teams take: fetch the vendor file on a schedule into your own infrastructure, diff it against the last approved copy, and publish it with an integrity hash only after a person or a rule approves the change. That turns a runtime fetch back into a build input you control, at the cost of delayed experiment changes and an approval step for each one. For sensitive pages that trade can be worth it.

How do you keep a script inventory and spot changes?

You cannot protect scripts you do not know about. Report URI's detection came from comparing crawled copies of vendor files over time; you can do the same for your own sites.

Build an inventory per page group. For each important page type (home, product, checkout, login, account), list every script that loads: first party bundles, each vendor tag, and the scripts those vendors load in turn. Record the owner, the business reason, the host, whether it is versioned or dynamic, and whether it runs on payment pages. The PCI Security Standards Council's information supplement on payment page security describes PCI DSS v4.x requirements 6.4.3 and 11.6.1 as ensuring that "payment page scripts are properly authorized, checked for integrity, and monitored for tampering". The standard itself is in the PCI SSC document library.

Watch what the browser actually receives. A synthetic job that loads each key page in a headless browser on a schedule, records every script URL and response body, hashes each one, and alerts when a hash changes gives you a baseline and a change signal. For dynamic files like experimentation snippets, alert on the parts that matter rather than every change: new hosts referenced, new uses of eval, atob or new Function, new script insertion, and new outbound endpoints. Searching for the attacker's domain alone would have missed Report URI's second loader variant, which hid the URL in base64.

Use CSP reports as a live sensor. A violation report is generated by a real visitor's browser at the moment a script tries something your policy forbids. Route reports to the same place your security alerts go, and alert on new blocked hosts, not just on volume.

Read the vendor's own change log. Optimizely's change history records changes to Project JavaScript and to variation CSS and JavaScript made in the Code Editor, with a Source filter that shows whether a change came through the REST API or the user interface. After this incident, review that history for every project for 13 to 17 November. Going forward, export or check it on a schedule. A change to Project JavaScript that no one on your team made is the single clearest sign of this attack.

Archive what you served. Hashed, timestamped copies of the vendor files your pages loaded answer "did we serve it, and when?" in minutes.

How should you control access to vendor and tag platforms?

Treat any tool that can push JavaScript to production as production access. That includes experimentation platforms, tag managers, customer data platforms with client side code, chat widgets with custom scripts, and content systems that allow raw HTML.

  • Single sign on and MFA. Optimizely's identity layer, Opti ID, supports SAML and OIDC identity providers (Opti ID overview). Its MFA documentation says the MFA toggle is "only available for local login" and that with SSO you "need to set it up with your own identity provider". It also warns that switching from local logins with MFA to SSO disables MFA, so enforce it in your identity provider before you switch.
  • Least privilege. Optimizely's collaborator roles separate administrators, project owners, publishers, restricted publishers, editors, restricted editors and viewers. Only administrators and project owners can change snippet settings and integrations, and restricted roles cannot use the code editor. Keep the number of people who can write code that runs on every page small, and give marketers restricted roles unless they truly need code access.
  • Change approval. Separate who writes code from who publishes it. Require a second person to review any change to project wide code and any experiment that adds custom JavaScript, especially on pages with forms.
  • API tokens and integrations. Report URI's advice to Optimizely customers includes reviewing "who and what has write access to your Optimizely account (users, API tokens, integrations)" and rotating credentials. Tokens used by automation are often older, broader and less watched than human accounts.
  • Leavers and agencies. Review collaborators quarterly and remove anyone without a current reason.

None of these stops a flaw on the vendor side, which is what Optimizely describes. They stop the version of this attack that starts with a phished marketer or a leaked token.

What should site owners do now?

Incident response for this kind of eventSite owner lane: contain, inspect, scope, rotate, notify, harden. Visitor lane: update iOS, check crypto transfers, watch card statements, reset sessions.Incident response for this kind of eventTwo lanes: what the site owner does, and what a visitor doesSite ownerContainpause Project JS,block IOC hostsInspectProject JS, customcode, historyScopepages, dates,payment formsRotatetokens, keys,non-HttpOnly cookiesNotifylegal, card brands,customersHardenCSP enforce,monitoring, accessVisitorUpdateiPhone and iPadto current iOSCheckcrypto transfersfrom 16 NovemberWatchcard statementsfor that dateResetsessions on sitesyou used that dayOwner steps follow Report URI and Optimizely guidance plus standard incident practice. Not legal advice.
Figure 5. Response lanes for site owners and visitors. Owner steps follow Report URI's and Optimizely's published guidance plus standard incident practice.

If you use Optimizely Web, work through these steps now, even though Optimizely says it has removed the injected code. Optimizely's statement covers its platform, not what your visitors' browsers ran or what your logs show.

  1. Check your projects. Open Project JavaScript and every experiment's custom code in every project, as Report URI advises. Search for 1688360.cc, atob(, eval(, webshell.lol, the page markers listed above, and any script you do not recognise.
  2. Read the change history. Review change history for 13 to 17 November for every project. Note any change to Project JavaScript you cannot attribute to a named person, and its time.
  3. Block the indicators. Add the IOC domains to your egress filtering, DNS blocklists and web proxy. Add explicit refusals in your CSP if your policy uses wildcards.
  4. Establish your exposure window. Use your own archives, CSP reports, CDN logs and real user monitoring to work out when your pages first and last served the injected code. If you have no record, assume exposure from 04:21 UTC on 16 November until at least 21:52 UTC, when Report URI still found one snippet infected, and from 13 November if you also load scripts from the vendors in its earlier wave, and check Report URI's per snippet times if you appear in its data.
  5. Scope card exposure. Report URI advises that if you have card fields in your own forms, treat cards entered on 16 November as potentially exposed. If your card entry uses a hosted payment iframe, record that fact and the evidence for it. Bring in your payment provider and acquirer early; card brand rules set the notification path.
  6. Rotate tokens and secrets. Report URI advises treating any session tokens or secrets in cookies that are not HttpOnly as exposed and rotating them. Invalidate sessions for affected page loads where you can, and mark session cookies HttpOnly and Secure going forward (MDN: Set-Cookie).
  7. Review accounts and tokens. Remove stale Optimizely collaborators, rotate API tokens, and confirm MFA is enforced in your identity provider.
  8. Decide on notification. Report URI suggests considering whether to tell customers you served them malware. Your legal and privacy teams will weigh card data, cookies and screenshots against your obligations in each jurisdiction. Write down the facts you used and when you learned them.
  9. Ask Optimizely for specifics. Ask which of your projects were modified, when, from which source, and when the code was removed. Ask for the postmortem when it is published and for the "additional protections" it mentions.
  10. Harden. Move CSP to enforce on sensitive pages, remove 'unsafe-eval' and scope 'strict-dynamic', tighten connect-src, img-src and form-action, put change monitoring on every vendor script, and decide whether experiments belong on checkout and login pages at all.

What should end users do?

If you visited a large brand's website on 16 November 2026, Report URI suggests the first three steps below; the fourth is general good practice:

  • Update your iPhone or iPad. Report URI advises iOS 18.7.3 or later, or iOS 26.3 or later. Apple's security releases page lists newer updates than those, so install the latest version available for your device. Google's researchers recommend Lockdown Mode for devices that cannot be updated (Coruna, DarkSword).
  • Check crypto transfers. Compare the address you meant to pay with the one the transfer went to. In general, confirm the first and last several characters of any pasted address before you send.
  • Watch card statements. If you paid by card on a large site that day, watch for transactions you did not make and report them to your card issuer.
  • Sign out and back in. Signing out of sites you used that day ends sessions whose cookies may have been copied.

What does this mean for security programmes?

SBOMs, dependency scanning and signed builds stop at the build boundary. A third party script runs in your product, under your brand, and never appears in your build. Three changes close most of the gap:

  1. Count browser loaded scripts as dependencies, each with an owner, a reason and a risk tier. Remove the ones nobody can justify.
  2. Make the browser enforce that inventory. An enforced CSP is the browser side equivalent of a dependency allowlist.
  3. Treat code pushing vendors as critical suppliers, with contract terms on breach notification, access logging and security testing. Ask how they would detect unauthorised changes to customer code, and how fast they would tell you.
Defence layers for third party JavaScriptFive stacked layers: vendor account and access control, script inventory and change monitoring, CSP script-src, CSP connect-src img-src and form-action, and payment and session design.Defence layers for third party JavaScriptNo single layer is enough; each one narrows what an injected script can doVendor account and accessSSO, MFA, least privilege, change approval, API token reviewStops misuse of your own accounts. A flaw on the vendor side is not covered.Script inventory and change watchHash and diff each vendor file; read vendor change historyCan flag a new loader soon after it appears.CSP script-srcExplicit hosts, nonces; no 'unsafe-eval'; scope 'strict-dynamic'Can block the second stage and the eval fallback.CSP connect-src, img-src, form-actionOnly the endpoints you knowCan stop data leaving even if the payload runs.Payment and session designHosted payment fields in an iframe; HttpOnly cookiesKeeps card numbers and session tokens out of page script.
Figure 6. Defence layers for third party JavaScript. Each one limits what an injected script can do; none is enough on its own.

Where does Safeguard fit?

Safeguard did not discover or report this incident, and nothing here should be read as saying Safeguard would have caught it. The fix for the vulnerability came from Optimizely, and the browser controls in this post (CSP, SRI, script monitoring) are yours to run whatever tools you use. Safeguard helps with the parts around them that sit in your software supply chain and compliance programme.

  • Vendor inventory and risk tiers. Safeguard's Third Party Risk Manager keeps a vendor directory with products used, contract status, risk tier, SBOM status and last assessment, and lets you link contracts that record security requirements and SBOM obligations. Use it to put every vendor that can run code on your pages in a tracked tier, with an owner and a review date.
  • Security header checks on your own sites. Safeguard's DAST tests running applications for runtime issues including missing security headers, against targets you have verified you own, with scope, rate limits and non destructive defaults enforced in code. Use it to confirm the pages you care about actually send the CSP you wrote.
  • First party JavaScript dependencies. Safeguard's software composition analysis and SBOM generation cover the npm packages bundled into your own front end, with vulnerabilities ranked by reachability, EPSS and CISA KEV status. That is the build side of the same page.
  • PCI DSS evidence. Safeguard's PCI DSS 4.0 framework mapping includes a Payment Script Integrity requirement mapped to requirement 6.4.3, which at SBOM level checks for integrity hashes on components, alongside component inventory and change controlled versions. Use the Compliance suite to collect the evidence an assessor asks for: your script inventory, approvals and monitoring records.
  • Policies, gates and approvals. Policies and gates can block, warn, notify or require approval at checkpoints in your pipeline, which is how you stop a release that changes your CSP or adds a new vendor without review.
  • An audit trail for your own security tooling. Safeguard records administrative, policy and integration changes in its audit trails, supports SSO with SAML and OIDC providers, and exports logs to your SIEM. The same access discipline this post recommends for your vendors applies to the tools you use to watch them.

FAQ

What happened in the Optimizely Web compromise?

On 16 November 2026, malicious JavaScript was added to the Project JavaScript of Optimizely Web customer projects and served from Optimizely's CDN to visitors of those customers' sites. Optimizely says an unauthorized party exploited a vulnerability in Experimentation to do it, and that it has fixed the vulnerability and removed the code (Optimizely status).

How many websites were affected?

Report URI reports 188 infected snippets belonging to 178 organisations among 1,611 snippets it checked, and says the true number is likely higher (Report URI). Optimizely has not published a number.

Would a Content Security Policy have stopped the Optimizely attack?

Only a strict one. Report URI reports that 24 of the affected sites it checked (from 256 crawled hosts) blocked the payload, and that the difference was a restrictive script-src. Allowing the Optimizely host did not help, 'strict-dynamic' let the second stage through, and 'unsafe-eval' let the inline fallback run. A tight connect-src stopped the data theft on 17 more hosts but not the in-page address swapping.

Did Safeguard detect the Optimizely compromise?

No. Report URI published the first detailed account and Optimizely confirmed the incident. Safeguard helps with vendor inventory, security header checks on your own sites, first party dependency analysis and compliance evidence around third party scripts.

The vulnerability in this incident had to be fixed by Optimizely, because it was in Optimizely's platform. But the scripts you bundle into your own front end, and the open source packages and images behind your services, are code you build and ship yourself, and there you do not have to wait for anyone.

Fix it without waiting for upstream

Whatever the vulnerability, most of the risk sits in two gaps. The first is the time between a fix being published and that fix actually running in your production builds. The second, and worse, is the time before any fix exists at all, while a maintainer works out a patch and a release schedule. Waiting through both gaps is a habit, not a requirement. Safeguard gives teams three ways to close them.

1. Autonomous remediation: pull requests, not tickets

When a fixed version exists, Griffin, Safeguard's security model, opens a policy gated pull request that moves the affected dependency to the safe version, and your own CI runs your tests on it before anyone merges. You can run it on one repository or in bulk across every project that carries the vulnerable version. Remediation categories include dependencies, licenses, security posture and findings, and each one is set separately. Reachability analysis ranks the vulnerable code paths your application actually calls first, so the first pull requests you merge are the ones that matter most. Auto-merge is a separate switch and stays off by default, so your team decides what merges on its own and what still needs a human approval.

2. Gold Open Source: the safe version in seconds, free

gold.safeguard.sh is free and needs no login. Search any CVE or package to see affected and fixed versions, CVSS, EPSS, CISA KEV status and a recommended safe version, or use the "Am I affected?" checker. The same data is available through a free read API, README status badges and RSS threat feeds.

3. Gold Registry: start from components that are already fixed

Safeguard Gold rebuilds patched versions of open-source packages and images from source, signs each build, attaches an SBOM, SLSA provenance and VEX, and serves them from registry.safeguard.sh to your organization. Every Gold artifact is held continuously to zero exploitable critical or high CVEs and a completed license check, with signed build provenance (signed with Safeguard's key and verifiable with cosign, SLSA Build Level 3 as the design target) and a public evidence page you can hand to an auditor. An artifact loses its Gold badge if it regresses. Teams can point their own package directory at the registry so hardened equivalents resolve without changing how developers install anything.

When upstream has no fix yet, or will not ship one, Safeguard first works to get the fix accepted upstream. If the issue is severe or upstream will not move, Safeguard builds a fork, fixes the vulnerability there and publishes a hardened Gold build, so you are not stuck on a maintainer's release schedule. You can also request a hardened build of a specific package. Ask which packages it covers before you plan around it.

Your situationWhat to use
A fixed version existsAutonomous remediation opens the upgrade pull request; Gold Open Source confirms the safe version
You need to know today whether you are affectedGold Open Source lookup and "Am I affected?" checker, free and without login
You want vulnerable versions to stop shippingSafeguard policies and gates in CI
Upstream has no fix yet, or will not ship oneA custom Gold request; fork and patch
You want to start clean on new projectsPull hardened components and images from Gold Registry

One honest limit: when the vulnerable code lives in a vendor appliance, a hosted service or an operating system runtime you do not build yourself, the fix still has to come from that vendor or distribution. The steps above apply to the open source dependencies and container images you build and ship, which is where most teams carry the largest and least tracked share of their exposure.

See how Safeguard would help

The first demo shows a dependency inventory built from a project's manifests. For a front end, that is the list of npm packages bundled into your own JavaScript, the part of the page you build and ship yourself. Third party scripts loaded at runtime from a vendor's server are not in that list, which is why the script inventory in this post is a separate job.

Click through it at your own pace, or open it full screen.

The second demo is a real Safeguard CLI session. You install the CLI, run safeguard to open the interactive terminal and ask it to fix a lodash CVE in a repository. It reads the vulnerability and the advisory, asks before any command that changes something, edits package.json to lodash 4.17.21, runs npm install and npm test with your approval, prints a summary and pushes nothing. That is the same flow you would use for a vulnerable package in your own front end bundle.

Click through it at your own pace, or open it full screen.

The third demo connects Claude to the Safeguard MCP server with OAuth and lets you choose which tools Claude can use. Once connected, you can ask an assistant to look up a package's affected and fixed versions while you plan front end dependency work.

Click through it at your own pace, or open it full screen.

To try it on your own projects, download Safeguard or start with the CLI documentation.

Quick check

Your CSP allows https://cdn.optimizely.com in script-src. Were you protected?

Not by that line. The malicious code was inside the file served from that host. What mattered was whether your policy refused the second stage script (no 'strict-dynamic' for the vendor), refused eval (no 'unsafe-eval'), and refused outbound requests to unknown hosts (tight connect-src and img-src).

Your connect-src blocked the attacker's host. Did your visitors lose anything?

Possibly. Report URI says sites in that group stopped the theft of cards, cookies and screenshots, but the in-page wallet address swap still worked, because it needs no network request.

Optimizely says it removed the injected code. Is your incident over?

No. You still need your exposure window, card and session scope, token rotation, a notification decision, and hardening. Optimizely's cleanup covers its platform, not what your visitors' browsers ran on the day.

Sources

Never miss an update

Weekly insights on software supply chain security, delivered to your inbox.

We email you a link to confirm, and only then add you to the list. Unsubscribe in one click. Privacy

Self-healing security runs on Safeguard.

Your first fix PR is minutes away.

No sales call required, even your agent can complete the purchase over MCP.