OPTIMJACK: When Trusted JavaScript Becomes a Supply Chain Attack
On November 16, 2026, attackers used a vulnerability in Optimizely’s Web Experimentation platform to inject malicious JavaScript into customer projects. Report URI researcher Scott Helme identified 188 infected snippets associated with 178 organizations, including Zoom, CNN, Salesforce, GitLab, IKEA and HSBC. The attackers did not need to modify those organizations’ application source code or compromise their web servers. Instead, the malicious code was delivered through Optimizely snippets that affected websites already trusted.
The payload could replace cryptocurrency wallet addresses, capture payment-card details entered into affected first-party forms, collect non-HttpOnly cookies and page screenshots, and attempt to deliver exploit kits to some iPhone and iPad users. The campaign, named OPTIMJACK by independent researcher Amirul Cyber, shows how a compromise of a trusted software provider can turn a routine third-party integration into a malware delivery channel.
For organizations that rely on third-party applications, JavaScript libraries, analytics platforms and cloud services, the incident raises a fundamental question: how can enterprises trust software whose code can change after it has been approved? The answer requires visibility not only into which providers are trusted, but also into the code they deliver and the behavior that code introduces.
How attackers turned a trusted platform into a malware delivery channel
Optimizely Web Experimentation lets organizations run A/B tests and personalize website experiences by loading JavaScript snippets associated with customer projects. These snippets can include Optimizely functionality, customer experiments and an optional Project JavaScript field that allows customers to execute custom code across their websites.
According to Report URI, the attacker inserted a small JavaScript loader into the Project JavaScript configuration of affected projects, leaving the rest of each snippet largely intact. The modified files continued to be served through Optimizely’s delivery infrastructure, so the browser received malicious code from a source the affected websites were already configured to trust.
Report URI documented several loader variations. One loaded a remote payload from 1688360[.]cc/track.js. Another concealed the destination with Base64 encoding, while a third embedded the payload and could use JavaScript’s eval() function as a fallback if the remote destination was blocked. Smartsheet’s snippet was cleaned and then reinfected, indicating that the attacker still had the ability to modify that project during the cleanup effort.
The scope was not limited to customer-branded sites. Report URI found that snippets associated with www.optimizely.com and login.optimizely.com also carried the loader. Some affected customers served their Optimizely snippets from their own domains rather than directly from cdn.optimizely.com. Examples included opt.scheels.com and www.vodafone.com.au. As a result, hunting only for requests to cdn.optimizely.com would miss some affected implementations; investigations should identify the Optimizely project snippets in use, including customer-hosted copies.
What Optimizely confirmed—and what remains unknown
Optimizely’s status-page notice says that an unauthorized party “exploited a vulnerability in Experimentation,” that the company “fixed the vulnerability” and removed the injected code from affected projects, took steps to “secure affected user accounts,” and put additional protections in place to prevent unauthorized code from being delivered. The status-page notice does not say that Optimizely “blocked the vulnerable path” or “revoked affected access tokens.”
The phrase “account signup flow” comes from an Optimizely spokesperson’s statement to Gizmodo, not from the status-page notice. It should therefore be attributed to the spokesperson rather than presented as wording from Optimizely’s official incident update. Helme’s assessment that this was not CDN cache poisoning is also his conclusion: the CDN delivered the content stored in affected customer projects. It is not a statement made by Optimizely.
Critically, the public reporting does not establish how the attacker obtained write access to so many unrelated customer projects. The signup-flow reference may identify the area in which the vulnerability existed, but it does not explain the mechanism that enabled cross-project modification. That question remains unanswered in the available public evidence.
A one-day injection, with roughly 16 hours of exposure for most sites
The Optimizely-specific injection was first observed on November 16, at 04:21 UTC in a BBC snippet, according to the timeline reported by Scott Helme. Report URI tracked cleanup throughout that same day: by 21:52 UTC, only one of the 188 infected snippets it had identified still contained the code, and its November 17 update said all infected files it monitored were clean by 23:11 UTC on November 16. StepSecurity estimates that most sites were exposed for about 16 hours.
November 13 is not the start date for the Optimizely injection. That date belongs to an earlier wave involving webshell.lol/get.js delivered through scripts associated with other vendors, including Kissmetrics, StorifyMe and Minute Media. The two waves are related in the researchers’ reporting, but their timelines and delivery paths should not be conflated.
The attacker’s domains were subsequently suspended. Report URI reported that 1688360[.]cc was placed on clientHold on November 17 at 00:37 UTC and webshell[.]lol at 03:37 UTC. These takedowns do not remove the need to review historical browser, proxy, DNS and script-response records from the November 16 exposure period.
One malicious script, multiple attack capabilities
The payload, identified as track.js, combined several malicious functions. Report URI observed 26 builds during November 16, with successive revisions adding functionality. Its capabilities depended on the visitor’s device and activity; the presence of the script does not establish that every function succeeded for every visitor.
Cryptocurrency address manipulation
The script searched page content and browser interactions for valid cryptocurrency addresses and could replace them with attacker-controlled destinations. Reported target networks included Bitcoin, Ethereum and other EVM-compatible chains, TRON, Solana, TON, Litecoin, Bitcoin Cash and Dogecoin. The replacement was conditional: the address had to appear near contextual terms such as “wallet,” “deposit” or “send.” The script could alter page text, form fields, clipboard activity and outgoing browser requests, creating a risk that a visitor would copy or submit a substituted address without noticing.
Report URI reported approximately $7,040 in cryptocurrency receipts associated with the attacker’s wallets by 19:25 UTC on November 16. That figure reflects observed on-chain receipts at that time, not a complete accounting of losses.
Payment-card skimming
A later payload version added a card skimmer that looked for card numbers, expiration dates and security codes submitted through website-controlled forms and browser requests. It did not collect the cardholder’s name or billing address. It also could not read card fields inside cross-origin hosted payment iframes, such as those commonly used by third-party payment providers. The distinction matters when organizations assess what information may have been exposed and determine whether breach-notification obligations apply: the observed skimmer’s collection capabilities should not be overstated.
Browser data and iOS exploit delivery
The payload could collect cookies that were not protected by the HttpOnly attribute and capture screenshots of affected pages using the html2canvas library. On iPhones and iPads, it also attempted to load additional code associated with the Coruna and DarkSword exploit kits. Report URI documented exploit-routing behavior for older iOS versions and a separate path for iOS 26 that appeared to perform device fingerprinting. The available evidence does not establish how many devices were successfully compromised or how many cookies, screenshots or payment-card records reached the attacker.
The bigger problem: Trusted software can change after approval
The most significant lesson from OPTIMJACK is not simply the range of malware functions. It is the trust relationship that made the attack possible. Modern websites depend on third-party code for analytics, experimentation, customer engagement, payments and marketing. These integrations may originate from reputable providers, use encrypted connections and load from domains explicitly approved by an organization. Those characteristics establish where software comes from; they do not prove that the code remains safe.
In this incident, organizations had legitimate business reasons to trust Optimizely and allow its JavaScript to execute in visitors’ browsers. What they could not necessarily verify was whether the code delivered through that relationship had changed maliciously. The compromise therefore bypassed controls focused primarily on internal repositories, source-code review and application release pipelines.
Vendor assessments and security reviews are snapshots in time. Third-party platforms can continue to change the code they deliver long after procurement and onboarding. Organizations need to understand which providers can introduce executable code, what those providers deliver, how that content changes and what behaviors it performs. Trust must be supported by ongoing verification, monitoring and investigation.
This responsibility also extends beyond engineering and security teams. Marketing, digital experience, analytics and customer-engagement teams often administer platforms capable of introducing executable code into customer-facing environments. Those systems provide business value, but their access and change-management processes require clear security ownership.
What existing security controls got right
Report URI’s analysis shows that Content Security Policy (CSP) configurations made a material difference for some affected sites. Its breakdown covered 159 sites: 24 blocked the malicious payload; 17 allowed the payload to run but blocked data theft through connect-src, although cryptocurrency address swapping still worked; 50 had a CSP that allowed everything relevant to the attack; and 68 had no CSP at all.
These categories should not be blurred. The 17 sites with connect-src restrictions were not fully protected: the policy limited exfiltration, but it did not stop in-page address substitution. The 50 permissive policies and 68 sites without a CSP should not be described as partially protected. Only the 24 sites in Report URI’s analysis blocked the payload.
The incident also demonstrates why allowing a vendor CDN is not, by itself, sufficient. The malicious code arrived inside a trusted Optimizely snippet. A restrictive script-src policy can prevent unapproved scripts from loading, while connect-src can limit where browser code sends data. The effectiveness of these directives depends on the actual policy, including whether it relies on broad trust relationships or permits unsafe evaluation. CSP is a defense-in-depth control, not a substitute for monitoring changes to trusted scripts.
Organizations should be cautious about presenting CSP as a control they or their peers necessarily have in place. The public ReversingLabs website, for example, does not currently return a Content-Security-Policy header in the SecurityHeaders.com check supplied for this review. The article therefore makes no claim that ReversingLabs itself is an example of CSP deployment.
Investigating malicious JavaScript with ReversingLabs
OPTIMJACK demonstrates why security teams need to investigate suspicious software artifacts after a potential exposure is identified. Browser-side controls can reduce the chance that malicious JavaScript executes, but incident responders also need to analyze suspicious code, investigate related infrastructure and determine whether artifacts connect to other malicious activity.
ReversingLabs supports these investigative workflows through its malware analysis and threat intelligence capabilities. Spectra Intelligence can be used to query suspicious file hashes, URLs and domains for available reputation, file analysis and network intelligence. Spectra Analyze supports deeper malware investigation and YARA-based hunting, while Spectra Detect can incorporate validated YARA rules into file-inspection workflows. These capabilities can help teams classify artifacts, investigate relationships and search for related activity; they do not, by themselves, prevent a browser from executing a malicious third-party script.
The public reporting cited in this article does not establish an independent ReversingLabs detection of OPTIMJACK. No RL-specific hash verdicts, first-seen timestamps, related-sample relationships or independently analyzed malware findings are asserted here. Those findings should be added only after an analyst has queried the relevant indicators in Spectra Intelligence, reviewed the underlying records and validated any related samples. This distinction keeps publicly reported research separate from product capabilities and any future RL analysis.
Detection and threat-hunting guidance
Organizations investigating possible exposure should determine whether compromised JavaScript was delivered to visitors and whether browsers subsequently contacted attacker-controlled infrastructure. Report URI identified 1688360[.]cc as the main payload and data-collection host, and reported webshell[.]lol in connection with the earlier injection wave. Additional domains associated with iOS exploit routing included 5vobauua3ojpklx[.]icu and eil786npto9u5bq[.]icu.
A publicly reported SHA-256 hash for a later build of track.js is f7b84b9a94f749f8ced3f0112d0a66894e8bbc3b4aa5592021d1b8976a9bad40. This is one known sample, not a complete signature for the campaign. Report URI observed multiple loader variations, encoded destinations and repeated payload changes. A search limited to this hash or to the literal string cdn.optimizely.com will therefore provide incomplete coverage.
Hunting should include historical copies of Optimizely project snippets and customer-hosted snippet domains, including opt.scheels.com and www.vodafone.com.au. Review project JavaScript and experiment-level custom code for unexpected script insertion, Base64-encoded destinations, references to 1688360[.]cc, and unfamiliar use of eval(). Correlate those findings with DNS, proxy and browser telemetry for requests to the payload and iOS-routing domains.
The Coruna loader is byte-identical to a loader Report URI analyzed in October in a different campaign. That relationship is useful context for threat hunting, but it should not be treated as proof that the two campaigns had the same operator or objective. Similarly, the appearance of webshell.lol in both the earlier wave and the Optimizely timeline supports investigating the relationship without collapsing the two exposure windows into one.
Detection logic should be developed and tested against preserved samples and legitimate website scripts before deployment. The sources cited here do not provide validated YARA rules, Sigma rules or a MITRE ATT&CK mapping for this incident. Any such rules or mapping presented as ReversingLabs analysis would need to be developed, tested and documented by RL analysts rather than attributed to the cited research.
What security teams should do now
Organizations using Optimizely Web Experimentation should review Project JavaScript configurations, experiment-level custom code and available change histories for unauthorized modifications. Include encoded and inline JavaScript in the review; do not rely exclusively on searches for known malicious domains. Identify every project snippet and the domain from which it was served, including customer-hosted domains. Review relevant project permissions, user accounts, API tokens and integrations with Optimizely, and preserve evidence of any suspicious changes.
Historical evidence is essential. A clean script retrieved today does not establish what visitors received during the incident. Preserve available script responses, response headers, CSP reports, browser telemetry, proxy records and DNS logs from November 16. These records can help reconstruct the exposure period, identify attempted exfiltration and determine whether further investigation or notification is warranted.
Assess potential exposure according to what the payload could actually collect. For payment cards, focus on card number, expiration date and security code entered into affected first-party forms; do not assume the skimmer collected cardholder names or billing addresses. Determine whether users copied or submitted cryptocurrency addresses while the affected page was open, and review non-HttpOnly cookies and relevant session information. Notification decisions should be based on the data actually at risk, applicable law and the evidence available.
Beyond incident response, review how third-party JavaScript is approved, monitored and governed. Restrictive CSP directives, continuous monitoring of externally delivered code, script integrity checks where technically appropriate, and clear ownership of third-party integrations can reduce exposure and improve detection. These practices should cover every platform capable of introducing executable code into customer-facing applications, not only experimentation tools.
Software trust cannot end at approval
OPTIMJACK shows how a trusted software dependency can become an attack delivery channel without attackers compromising the websites that rely on it. A malicious change to vendor-managed JavaScript was enough to expose visitors across at least 178 organizations’ websites. The incident demonstrates that software supply-chain risk extends beyond traditional packages and development pipelines into services that continuously deliver code to enterprise applications.
For security leaders, vendor reputation, approved infrastructure and initial security assessments are necessary but insufficient foundations for software trust. Organizations need ongoing visibility into the code being delivered, the ability to identify suspicious changes and the intelligence to investigate malicious behavior when it appears. Trust in software must be supported by continuous visibility and verification—not simply inherited from the provider delivering it.
Get a Free Trial of ReversingLabs
Investigate suspicious software, uncover malicious behavior and accelerate threat hunting with ReversingLabs. Get hands-on access to malware analysis and threat intelligence capabilities to identify threats, analyze suspicious artifacts and make more informed security decisions.
Further reading
- Report URI: World’s Largest Brands Infected With Malware Via Optimizely — https://blog.report-uri.com/worlds-largest-brands-infected-with-malware-via-optimizely/
- StepSecurity: OPTIMJACK: Optimizely-Hosted Scripts Loaded a Crypto Clipper and Card Skimmer — https://www.stepsecurity.io/blog/optimjack-optimizely-hosted-scripts-crypto-clipper-card-skimmer
- Optimizely: Web Experimentation Security Incident (specific incident page) — https://status.optimizely.com/incidents/ftw0fh9wx43z
- Gizmodo: Sprawling Malware Attack Reportedly Affects Zoom, CNN, Fox News, Peacock, and 170+ Others — https://gizmodo.com/sprawling-malware-attack-reportedly-affects-zoom-cnn-fox-news-peacock-and-170-others-2000840831
- Amirul Cyber: OPTIMJACK – Optimizely Skimmer — https://amirulcyber.com/2026/11/16/optimjack-optimizely-skimmer/