OPTIMJACK: When the Vendor’s Script Is the Attack

Table of Contents

OPTIMJACK: When the Vendor’s Script Is the Attack

A field guide to the Optimizely supply chain compromise, the third-party script exposure most web security programs don’t account for, and the queries to find it

It hit 178 organizations in one day. Nothing was wrong with their code, and your code review would not have caught it.

On November 16, 2026, an unauthorized party wrote malicious JavaScript into 188 Optimizely Web Experimentation projects belonging to 178 organizations. For about 17 hours, from the first injection to the last infected snippet observed, the production pages of Zoom, the BBC, CNN, Fox News, NPR, Salesforce, GitLab, IKEA, HSBC, Equifax, Air France-KLM, and Ledger served a multi-purpose malware kit to visitors. Optimizely’s own site and login page carried it too.

This is an advisory built from the first 24 hours of public reporting, not a closed-case writeup. The primary telemetry comes from Report URI, with payload analysis from StepSecurity, endpoint-side discovery from Cynet, and additional analysis from Hudson Rock and Ohey. Optimizely has not disclosed the entry mechanism. More detail may follow as that changes.

What follows covers what the attacker did, how the delivery chain works, who was actually exposed, what to hunt for, and why cleaning one field is not the same as being clean.

What Happened

Optimizely customers load a JavaScript snippet from cdn.optimizely[.]com. The snippet carries the customer’s experiments plus an optional Project JavaScript field, which is customer-authored code that runs on every page of the site. The attacker wrote a loader into that field. The rest of each snippet was untouched, and the file was still served from Optimizely’s content delivery network (CDN) with Optimizely’s certificate, from a host every affected site already trusted.

Report URI checked 1,611 Optimizely snippets and found 188 infected. That number is a floor. They could only check the snippets they found in time. Report URI states this was not CDN cache poisoning. The CDN served exactly what it was given.

Not every victim reached the payload through Optimizely. Amirul Cyber captured 15 page loads that fetched it. Twelve came through Optimizely bundles and three through adjacent routes: an ad-tech wrapper, a first-party bundle, and a script protected by a code-obfuscation product. That is one researcher’s capture, but it matters for scoping. Searching only for Optimizely will miss some exposure.

Vendor Response and What Is Still Unknown

Optimizely posted a security incident notice at 01:02 UTC (Coordinated Universal Time) on November 17, 2026. It states that an unauthorized party exploited a vulnerability in Experimentation and added malicious JavaScript to some customer projects, that it fixed the vulnerability and removed the injected code, and that it secured affected user accounts and added protections against unauthorized code delivery. I could not read the status page directly, so any further remediation steps in press reports are unconfirmed.

Optimizely told reporters the flaw was in the account signup flow. That statement does not explain cross-tenant write access to 188 projects across 178 organizations. The notice does not give the project count, the fix timeline, or whether the attacker still has access. Report URI reported no response to its outreach at the time of publication.

Customers moved faster than the vendor. Salesforce told Reuters it was investigating unauthorized Optimizely changes and had disabled the scripts as a precaution.

Two timeline points support the question of residual access. The Smartsheet snippet was cleaned and then re-infected with a base64-hidden variant, so the attacker still had write access mid-day. Mass cleanup ran from about 20:40 to 21:10 UTC, and by 21:52 UTC only one snippet was still infected. Report URI’s later update puts full cleanup at 23:11 UTC. The payload domain 1688360[.]cc was suspended by its registrar at 00:37 UTC on November 17.

What the Payload Does

The payload was a single JavaScript file of about 30 kilobytes, built 26 times in one day. It has three functions and an iOS branch.

Crypto address clipper. It holds replacement addresses for 8 blockchains (Ethereum, Tron, Bitcoin, The Open Network, Solana, Litecoin, Bitcoin Cash, Dogecoin). It swaps only addresses that pass the chain’s checksum, and only when nearby text contains a payment word such as wallet, deposit, or send. It hooks page text, form inputs, the clipboard API (application programming interface, the way page code talks to the browser), share APIs, outgoing fetch and XMLHttpRequest (XHR, the browser’s older network request tool) bodies, and Function.prototype.call and apply.

Card skimmer. Added at 13:43 UTC. It wraps fetch and XHR, then looks for a card number that passes the Luhn check (the checksum every real card number satisfies) with a known brand prefix, a valid expiry date, and a CVV (the card security code). It sends them to the attacker’s command-and-control (C2) server with sendBeacon (a browser function for sending data in the background). It cannot read fields inside cross-origin payment iframes (pages embedded from another site) such as Stripe hosted fields. Cards typed into a site’s own form fields were reachable.

Cookie and screenshot theft. After the first address swap, it loads html2canvas, renders the visible page as a JPEG, and posts it with up to 8,000 characters of document.cookie. HttpOnly cookies (cookies flagged so page scripts cannot read them) are out of reach.

iOS exploit-kit staging. On iPhone, iPad, and iPod user agent strings (the browser identity a page sees) it loads boot.js from .icu domains and opens an exploit chain in a hidden iframe. Coruna and DarkSword are both iOS exploit kits. Delivery to visitor browsers is reported. A successful device compromise is not demonstrated.

Money counted so far is small: about $7,040 received by 19:25 UTC on November 16 by Report URI’s count, and nearer $6,600 by StepSecurity’s. Treat both as upper bounds. The cards, cookies, and screenshots left no on-chain trace, and no organization has published a confirmed skimming victim count.

The Delivery Chain

The attacker obtained write access to customer projects across unrelated tenants and wrote a script element into each Project JavaScript field, pointing at 1688360[.]cc/track.js. The mechanism is unconfirmed. Every page load then executed the snippet from cdn.optimizely[.]com or from the customer’s own domain. Consent banners control when the snippet runs, not what it contains, and on GitLab the consent manager is what loads the Optimizely bundle. The server sent a cache lifetime of 15 seconds, so the operator could swap the file within seconds, and did so 26 times in one day. Three loader variants kept it alive after a domain block: a plain script tag, a base64-hidden URL, and a full inline copy that runs through eval. At 13:03 UTC the operator swept stolen funds toward exchanges.

By the time a site owner removes the loader, the attacker has already had a full day of production access, a payload that rewrote itself 26 times, and a fallback copy that blocking the domain would not have stopped.

Who Was Exposed

Two different exposures sit under the word “mobile,” and a third sits under “hardware.” They should not be merged.

Visitor on an affected page Exposure Evidence
Copied or pasted a crypto address Address swapped to the attacker’s Capability verified, on-chain receipts counted
Typed a card into the site’s own form Card number, expiry, CVV skimmed Capability verified, victim count unknown
Paid through a hosted Stripe or Adyen iframe Not reachable by the skimmer Reported behavior
Handled an address on a page, with non-HttpOnly cookies Cookies and a page screenshot sent Conditional on an address swap
iPhone or iPad in a kit’s version range Exploit kit delivered Delivery reported, compromise unproven
Windows or macOS computer Browser-side theft only No exploit stage reported
Android Browser-side theft only No exploit stage reported

iPhones and iPads: delivery reported, compromise unproven. The report describes boot.js running only for iPhone, iPad, and iPod user agents. Cynet retrieved boot.js with an emulated iPhone and describes conditional delivery, not a compromised device. StepSecurity confirmed the Apple-specific loading behavior but said it had not independently analyzed the exploit files or verified the exact chains and affected versions. Hudson Rock says it has not independently reproduced the later iOS stages or demonstrated compromise of a real victim’s iPhone, and that a scan using an iPhone user agent is a delivery observation, not a Safari exploitation test. Ohey’s Kirk documented later iOS stages built to steal keychain data, seed phrases, and private keys. Confidence that any real device compromise occurred is low, 35 out of 100.

Windows and macOS computers: exposed to the browser-side theft only. The exploit-kit loader runs only for iPhone, iPad, and iPod user agent strings, and no public source reports a Windows or macOS exploit stage. A visit would not have given the attacker control of the machine. A user who typed a card into an affected site’s own form, or copied or pasted a crypto address on an affected page on November 16, is exposed the same way as on any other device. DNS and Defender hits on these endpoints mean the browser loaded the loader, not that the machine was compromised. That is an absence-of-evidence finding as of November 17, 2026.

Android devices: exposed to the browser-side theft only. Coruna and DarkSword are iOS exploit chains. No public source describes an Android exploit stage in this campaign. That is an absence-of-evidence finding as of November 17, 2026. The clipper, skimmer, and cookie theft run in the page, so an Android visitor who entered a card into a site’s own form, or handled a wallet address on an affected page, carries the same exposure as a desktop user.

Hardware wallets: the site was affected, the device was not. Ledger, a hardware wallet maker, was on the victim list, and its site carried the loader until cleanup at 20:41 UTC. No source describes hardware wallet firmware or devices being compromised. Network equipment such as routers, firewalls, and industrial controllers is not part of this campaign. Separate advisories on those devices exist, and nothing links them to OPTIMJACK. The clipper rewrites addresses in the browser, so comparing the destination on the hardware wallet’s own screen against the address you meant to pay defeats it. Comparing against copied text does not.

Which iOS versions matter. Published exploit ranges are narrower than the “iOS 18.6 or earlier” trigger in the payload. Coruna is documented against iOS 13 through 17.2.1, and DarkSword against iOS 18.4 through 18.7. Lookout notes that 18.4 through 18.6.2 are not susceptible to the Coruna chains.

That puts the real exposure at Coruna on iOS 17.2.1 and earlier, and DarkSword on iOS 18.4 up to the fully patched release. This is my reading of the published ranges, not a vendor statement.

Patch guidance, and why you will see conflicting numbers. Most coverage of this incident repeats “update to iOS 18.7.3 or later, or 26.3 or later.” That figure comes from comments in the attacker’s own code. It fixed two of the six vulnerabilities DarkSword chains. Other sources cite 18.7.5 or 18.7.6 and 26.3 or 26.3.1 as the releases with all of them patched, and they disagree on the exact number. Update to the current release and verify against Apple’s security notes.

Why the Standard Stack Missed It

The site’s own code is clean. The change lives in a vendor-hosted file, so code review, repository scanning, and static application security testing (SAST) never see it.

Subresource Integrity (SRI, a hash check that pins a script to one exact version) is hard to apply. A snippet that changes every time a team publishes an experiment cannot be pinned to one hash. Change-detection monitoring is the substitute.

Allowlisting cdn.optimizely[.]com in a Content Security Policy (CSP, the browser rule list for which scripts and connections a page may use) was never going to help. The malicious code came from the trusted host itself.

What CSP Actually Did

A Content Security Policy (CSP) is a rule list a website sends to the browser, usually as an HTTP header. It tells the browser which sources a page may load scripts from and which servers it may send data to. The browser enforces it, so it still works when the vendor’s file is the thing that has been tampered with.

  • script-src controls where scripts may come from. For example, “only run scripts from our own domain and from cdn.optimizely[.]com.”
  • connect-src controls where the page may send data, including fetch, XMLHttpRequest, and sendBeacon calls. For example, “only talk to our own servers.”

Report URI evaluated the CSPs on 256 hosts across affected organizations. The four outcome counts below sum to 159, and the reported 15% is 24 of 159. The coverage I could read does not explain how 256 hosts map to 159 organizations, so treat the base as 159.

Result Organizations
No CSP at all 68
CSP allowed the payload and the data theft 50
Payload ran, connect-src blocked the data theft 17
Payload blocked 24 (15%)

 

What separated the 24 protected sites was a restrictive script-src listing only the hosts the site needs. Three details matter for your web team:

‘strict-dynamic’ (a setting that trusts any script a trusted script loads) lets the attack through. Any script the trusted Optimizely snippet inserts is trusted too.

‘unsafe-eval’ (a setting that permits running code from text strings) lets the inline fallback run. That is what happened at HSBC. Its CSP blocked track.js and the data theft, but the inline copy still ran. Report URI notes that Optimizely’s own documentation recommends allowing ‘unsafe-eval’, so a customer who followed the vendor’s guidance was exposed to this fallback.

connect-src is the second half of the answer. The 17 partial sites blocked card, cookie, and screenshot exfiltration but not the in-page address swapping.

Threat Hunting

The hunt lives in DNS (domain name system lookups), proxy, and endpoint network telemetry for your users, and in the snippet content itself for site owners. Each hypothesis below describes a behavior the campaign produced, followed by a hunt to test it. The Kusto Query Language (KQL) below comes from the public Report URI and StepSecurity indicator of compromise (IOC) lists and has not been validated against live tenant traffic by us. Confirm table availability, field names, and result volume in your own environment before treating any of it as a deployable rule. Run each query against a known-good window first. Published IOC lists also deserve validation before they become blocklist entries. StepSecurity found one of the listed fallback domains, q1ls1ho9x7wsxlu[.]icu, absent from DNS and WHOIS (domain registration records) at 22:07 UTC on November 16.

Hypothesis: a client or your own site loads Optimizely and has not been checked

For a managed security service provider (MSSP), this is the first question. Scan client public pages for references to cdn.optimizely[.]com/js/ and for self-hosted proxy paths that serve an Optimizely project file, then sort clients into those who use Optimizely and those who do not. Do the same for the adjacent routes: scripts from Kissmetrics, StorifyMe, and minute-ly, which Hudson Rock and Ohey linked to the same loader code starting November 13.

Hypothesis: users resolved or connected to the OPTIMJACK infrastructure

The window starts at 04:00 UTC on November 16, 2026, which covers the first injection.

Hunt. Pull DNS lookups for the IOC set:

let iocs = dynamic(["1688360.cc","webshell.lol","linkforge.cc","ios-hack.icu",
"5vobauua3ojpklx.icu","eil786npto9u5bq.icu","l7bcsnwc7nzr3uo.icu",
"je4ft3gn8vxudum.icu","q1ls1ho9x7wsxlu.icu","p55abnw2pnsz0bo.icu",
"1y69gy2mdzaltz1.icu","gm38duxoihbmy5o.icu"]);
DnsEvents
| where TimeGenerated between (datetime(2026-11-16 04:00) .. datetime(2026-11-17 23:59))
| where Name has_any (iocs)
| project TimeGenerated, ClientIP, Name, Result

A hit means a user’s browser loaded a page carrying the loader. It does not mean the user’s endpoint was compromised.

Hypothesis: workstations connected directly to the payload host

Hunt. Run the same window against Microsoft Defender endpoint telemetry:

DeviceNetworkEvents
| where Timestamp between (datetime(2026-11-16 04:00) .. datetime(2026-11-17 23:59))
| where RemoteUrl has_any ("1688360.cc","webshell.lol") or RemoteIpAddress in ("136.113.106.136")
| project Timestamp, DeviceName, RemoteUrl, RemoteIpAddress, InitiatingProcessFileName

Treat the output as a candidate list. The browser process on the device is the expected initiator. Most iPhones and iPads have no endpoint detection and response (EDR) software, and devices on cellular never touch corporate DNS or proxy, so a clean result for mobile is weak evidence.

Hypothesis: a snippet you serve is still carrying the loader

This is a manual or scripted review, not a single query. Fetch every Optimizely snippet you serve, including self-hosted paths, and search for 1688360, atob(, eval(, cc_, window._k7, and data-channel-code=“02111110”. Also review every script you did not write. Record each file’s Last-Modified header. A clean snippet today does not prove it was clean on November 16.

Hypothesis: the loader was present on pages where it failed to execute

CSP violation reports and proxy deny logs for 1688360[.]cc identify pages where the loader was present even where execution failed. This is the evidence that a blocked request still happened.

Hypothesis: an iPhone or iPad in a vulnerable range loaded an affected page

Build the exposed population from DNS and proxy hits on the IOC set, and from mobile device management (MDM) or mobile threat defense telemetry if you have it. Tier by iOS version from MDM inventory:

  • iOS 18.4 up to the fully patched release (DarkSword range)
  • iOS 17.2.1 and earlier (Coruna range)
  • Everything else on 18.6 or earlier, lower priority
  • Fully patched releases: confirm the version and take no further action

For tier 1 and 2 devices with IOC contact, collect crash logs, sysdiagnose data (Apple’s diagnostic bundle), and a backup for analysis. These kits are built to leave little behind. They inject into trusted processes and execute in memory, so a clean result does not clear a device. If a device is in range, had IOC contact, and holds sensitive access, treat it as potentially compromised: revoke sessions and tokens for the accounts on it, rotate credentials, and wipe or replace per your risk call.

Additional hypotheses worth building into your hunting program

Browser artifacts. window._k7, window._cc, window._qxc, window._shot, sessionStorage keys starting with cc_, and non-native Function.prototype.call or apply on a page. On iPhones and iPads in range, a page that reloads every 60 seconds is a visible symptom of the exploit retry.

Behavior over hashes. The payload changed 26 times in a day. Match on domains and behavior, not a single file hash.

Do not block the CDN. Treat cdn.optimizely[.]com as a legitimate delivery host, not an indicator. Broad blocks of that host or of the affected news sites cause outages and catch nothing.

Protective Controls

Ordered by return on effort, highest first.

  • Contain first. If you cannot confirm your snippet is clean, pause or unpublish it, or disable Project JavaScript, until the vendor gives you a change history. Salesforce disabled its Optimizely scripts as a precaution. Pull the snippet from checkout and login pages before anything else.
  • Remove third-party tags from checkout and login pages. Take card details only through the payment provider’s hosted cross-origin iframe fields, which this skimmer cannot read.
  • Deploy a strict script-src and connect-src, with reporting turned on. Avoid ‘unsafe-eval’ and reconsider ‘strict-dynamic’ for tag-injected scripts. This is the control that stopped 24 organizations outright.
  • Update iPhones and iPads to the current iOS release. Enable Lockdown Mode for high-risk users such as executives, incident response (IR) staff, and anyone with administrative access.
  • Keep secrets out of non-HttpOnly cookies. The cookie theft only reaches what JavaScript can read.
  • Treat any third-party script that runs customer-authored code as a privileged integration. The same exposure class applies to tag managers, analytics loaders, and any multi-tenant software-as-a-service (SaaS) product that executes code on your production pages.

Safe Site Recovery: A Practitioner’s Checklist

The question that comes up in every supply chain script compromise: when is it actually safe to consider the site clean?

The short answer is that removing the loader is necessary and not sufficient. Before closing out an incident involving an affected Optimizely project, confirm each of the following:

  • The Project JavaScript field and the custom code of every experiment have been reviewed by a person, not only searched for 1688360
  • Variants have been checked for, including base64-hidden URLs and inline payloads, not only the plain script tag
  • Snippets served from your own domain have been checked, not only those served from cdn.optimizely[.]com
  • Other third-party scripts on the same pages have been checked, since some visitors reached the payload through adjacent routes
  • Every user, API token, and integration with write access has been reviewed, and credentials have been rotated
  • Optimizely has told you in writing which projects were changed, when, and through which accounts
  • A scheduled fetch that diffs each served snippet, including self-hosted copies, is in place, since Subresource Integrity cannot pin a file that changes with every published experiment
  • Cards entered into your own forms on November 16 are treated as exposed, and secrets in non-HttpOnly cookies are rotated
  • Your customers have been told that your site served them code that day, if your counsel agrees

Treat the site as contained only once every item above is confirmed. A clean snippet today does not prove it was clean yesterday.

What This Means for Your Program

Three items from everything above are worth escalating to leadership directly, since each is an ownership and resourcing question rather than something an analyst can fix alone.

First, confirm that someone owns an inventory of every third-party script that executes on your production pages, and who can write to each one. Most organizations cannot answer this. If you cannot, that is the gap this incident exploited, and closing it needs an owner and time, not a config change.

Second, if your CSP does not have a restrictive script-src and connect-src with reporting, bring this case to whoever owns that decision. 24 of the 159 organizations in Report URI’s evaluated set (15%) blocked this attack with a strict policy. It is the first quantified measurement of CSP efficacy against a live, mass-parallel skimming campaign.

Third, if you take card payments, check your Payment Card Industry Data Security Standard (PCI DSS) position. Requirements 6.4.3 and 11.6.1 under PCI DSS 4.0, mandatory since March 31, 2025, require merchants to inventory, authorize, and integrity-check every script on payment pages and to detect tampering. This incident is the case those requirements were written for. Confirm the requirement wording with your assessor.

What We Don’t Know

Optimizely has not explained how a signup-flow flaw produced cross-tenant write access, how many projects were changed, when the fix shipped, or whether the attacker’s access is fully closed. No organization has published a skimming victim count. No successful iPhone or iPad compromise has been demonstrated, and no public source describes an Android exploit stage.

On attribution, our confidence is very low, 10 out of 100. Report URI ties the injector webshell[.]lol to the same actor and traces earlier deliveries through Kissmetrics, StorifyMe, and minute-ly scripts from November 13. Hudson Rock and Ohey say the deliveries share hosting and loader code, which does not prove a single operator or a common way in. The evidence is consistent with a financially motivated criminal operation, not a state actor, and it supports nothing more.

The class matters more than the vendor. On September 14, 2026, attackers used a stolen Cloudflare API key to inject malicious scripts into Brevo’s sites and into JavaScript files embedded on customer sites. Two vendor-side script compromises in two months is a pattern.

The effective attack surface of a website includes every SaaS script it embeds. One vendor-side write reached 178 organizations with no signal on any of their own infrastructure. The indicators that matter here are behavioral and structural, not static, and they need to be built before the next vendor is the one that gets hit. If your response to a script compromise still stops at blocking a domain, you now know why that is not enough.

Related Blogs

Cybersecurity Videos
Cloud Security

Thrive experts discussing Cloud Security.

Cybersecurity Life Sciences Videos
Cybersecurity Fundamentals

When it comes to cybersecurity threats, being unprepared can cost a business millions.

Blog Cybersecurity
Secure Score – Blocking Automatic Forwarding

Secure Score is a service provided by Microsoft to give administrators a guideline of how to better secure their tenant. Think of it as a credit score for Office 365. Guideline tasks can vary from…