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-srcwithout'strict-dynamic'or'unsafe-eval', plus tightconnect-srcto 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".
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:
- A plain script tag pointing at
https://1688360.cc/track.js, in most snippets. - The same URL hidden in base64 and decoded with
atob(), so "a search for '1688360.cc' won't find it". - A full inline copy of the payload, which "runs through
evalif1688360.ccis 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) | Event | Reported by |
|---|---|---|
| 17 Sep | The same actor's injector, webshell.lol, first appears on other sites | Report URI |
| 9 Nov 17:52 | First iOS router domain registered | Report URI |
| 13 to 16 Nov | Earlier wave injects webshell.lol/get.js through other vendors' scripts | Report URI |
| 02:21 | Last clean capture of one affected Optimizely snippet | Report URI |
| 04:21 | First Optimizely injection observed | Report URI |
| 05:23 | 1688360.cc registered (certificates issued from 04:28) | Report URI |
| 08:10 | First build of track.js | Report URI |
| 08:28 | track.js first seen on a live site | Report URI |
| 13:03 to 13:05 | Stolen crypto swept to exchanges | Report URI |
| 13:43 | Card skimmer added to track.js | Report URI |
| 16:38 | Second iOS router domain registered | Report URI |
| 17:13 to 17:57 | Second iOS host added; Coruna iframe injected | Report URI |
| 19:24 to 19:59 | Report URI sweep: 186 of 1,611 snippets infected | Report URI |
| about 20:40 to 21:10 | Mass cleanup of infected snippets | Report URI |
| 21:00 to 21:29 | Poisoned files recovered for analysis | Hudson Rock |
| 21:52 | One of 188 infected snippets still infected | Report URI |
| 17 Nov 01:02 | Status page: vulnerability fixed, code removed | Optimizely |
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.
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 URI | Count |
|---|---|
| No CSP at all | 68 |
| CSP allowed the payload and the data theft | 50 |
| Payload ran, but connect-src blocked the data theft (address swapping still worked) | 17 |
| Payload blocked | 24 (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.
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.
- The snippet loads. Your
script-srcallows 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. - 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." - The fallback runs the payload through
eval. Without'unsafe-eval'inscript-src, the browser refuses. With it, the inline copy runs even wheretrack.jswas blocked, as Report URI observed. Report URI lists'unsafe-inline'as the other setting that lets this fallback through. - The payload sends data out. A
connect-src(andimg-src, since images are a common beacon channel) limited to known endpoints refuses requests to1688360.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-srclists 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 as1688360.ccis refused. There is no'unsafe-eval', so the eval fallback is refused. There is no wildcard such ashttps://*.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-srcincludes'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-srcandconnect-srcare where data theft is decided. Only the endpoints your page actually calls are listed: your own origin, the vendor's event endpoint (logx.optimizely.comin Optimizely's guidance), and your payment provider's API. Requests tocard.phporhit.phpon any other host are refused.frame-srcallows 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'andobject-src 'none'close two old bypasses.report-tosends 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 useshttps://*.optimizely.complus 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 toconnect-src: the guidance addshttps://*.optimizely.comalongsidelogx.optimizely.com, so expect to add specific Optimizely hosts there too. - The
frame-srcentry 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 secondcdn-pciframe 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?
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.
- 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. - 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.
- 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.
- 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.
- 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.
- 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).
- Review accounts and tokens. Remove stale Optimizely collaborators, rotate API tokens, and confirm MFA is enforced in your identity provider.
- 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.
- 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.
- Harden. Move CSP to enforce on sensitive pages, remove
'unsafe-eval'and scope'strict-dynamic', tightenconnect-src,img-srcandform-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:
- Count browser loaded scripts as dependencies, each with an owner, a reason and a risk tier. Remove the ones nobody can justify.
- Make the browser enforce that inventory. An enforced CSP is the browser side equivalent of a dependency allowlist.
- 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.
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 situation | What to use |
|---|---|
| A fixed version exists | Autonomous remediation opens the upgrade pull request; Gold Open Source confirms the safe version |
| You need to know today whether you are affected | Gold Open Source lookup and "Am I affected?" checker, free and without login |
| You want vulnerable versions to stop shipping | Safeguard policies and gates in CI |
| Upstream has no fix yet, or will not ship one | A custom Gold request; fork and patch |
| You want to start clean on new projects | Pull 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
- Optimizely status page: Web Experimentation Security Incident (17 November 2026, 01:02 UTC)
- Report URI: World's Largest Brands Infected With Malware Via Optimizely (Scott Helme, 16 November 2026)
- Hudson Rock research team on infostealers.com: poisoned vendor scripts and iPhone exploit loaders (16 November 2026)
- Optimizely docs: When to use custom code, shared code, Project JavaScript and extensions
- Optimizely docs: Update your site's Content Security Policies (CSP)
- Optimizely docs: View change history
- Optimizely docs: Manage collaborators
- Optimizely docs: Opti ID, set up multi factor authentication
- Optimizely support: Overview of Opti ID
- Google Threat Intelligence Group: Coruna iOS exploit kit (4 March 2026)
- Google Threat Intelligence Group: DarkSword iOS exploit chain (19 March 2026)
- Apple security releases
- W3C: Content Security Policy Level 3
- W3C: Subresource Integrity
- W3C: Trusted Types
- MDN: Content Security Policy guide
- MDN: CSP script-src
- MDN: CSP connect-src
- MDN: CSP report-to
- MDN: Content-Security-Policy-Report-Only
- MDN: Subresource Integrity
- MDN: Set-Cookie
- web.dev: Mitigate cross site scripting with a strict CSP
- OWASP: Third Party JavaScript Management Cheat Sheet
- OWASP: Content Security Policy Cheat Sheet
- OWASP: Top 10 Client Side Security Risks
- PCI Security Standards Council: information supplement on payment page security and preventing e-skimming (10 March 2025)
- PCI SSC document library (PCI DSS v4.0.1)
- Safeguard docs: Application Security Testing (SAST and DAST)
- Safeguard docs: Vendor Management
- Safeguard docs: PCI DSS 4.0 framework
- Safeguard docs: Policies and Gates
- Safeguard docs: Audit Trails
- Safeguard docs: Generate SBOM
- Safeguard docs: SSO Authentication