As reported by The Hacker News, a vulnerability in Optimizely Web Experimentation allowed an attacker to inject malicious JavaScript into customer projects, delivering card skimmers and an iOS exploit kit to visitors of at least 178 organizations including CNN, the BBC, and Zoom. This is a textbook supply chain compromise — but the blast radius and the trust model that enabled it deserve closer scrutiny than the headline.

Security Impact: As reported by The Hacker News, a vulnerability in Optimizely Web Experimentation allowed an attacker to inject malicious JavaScript into customer projects, delivering card skimmers and an iOS exploit kit to visitors of at least 178 organizations including CNN, the BBC, and Zoom.

Why This Matters Beyond the Headline Count

The 178-organization figure is likely a floor, not a ceiling. Report URI detected the malicious scripts through their monitoring network, but any organization loading Optimizely snippets outside that visibility — including self-hosted snippet deployments, which the article confirms were also affected — would not appear in that count. The real exposure could be significantly larger.

What makes this incident particularly damaging is why the malicious code ran without triggering browser protections. The snippets were served from cdn.optimizely.com with Optimizely's own valid TLS certificate. For organizations relying on Content Security Policy (CSP) to prevent unauthorized script execution — a defense-in-depth measure many enterprises invest significant effort in maintaining — this attack bypassed those controls entirely. The browser had no way to distinguish legitimate Optimizely JavaScript from attacker-injected code because both came from the same trusted origin.

This is the fundamental weakness of the third-party script trust model: when a SaaS vendor's CDN is compromised, every customer's CSP, every SRI hash, and every domain allowlist becomes irrelevant because the malicious code is served from the same trusted infrastructure as the legitimate code.

The Persistence Problem

One detail that deserves more attention: Smartsheet's script was cleaned and then re-infected with a hidden version of the loader. This suggests the attacker retained write access to customer projects even after initial remediation attempts. Optimizely's incident notice — posted at 01:02 UTC — does not clarify whether all attacker access has been revoked, how many projects were modified, or when the vulnerability was actually patched. This opacity is a problem for defenders who need to make risk decisions about continued use of the platform.

Technical Indicators from Report URI's Analysis

The Persistence Problem
Delivery mechanism: Malicious loader injected into Project JavaScript field of customer projects
Payload domains: 1688360[.]cc/track.js (primary), with base64-obfuscated and self-contained fallback variants
Capabilities: Card detail capture, crypto wallet address substitution, iOS exploit kit second-stage loading
Detection evasion: Three loader variants including one that embeds the full payload to function even if the C2 domain is blocked

Who Is Most Exposed

Organizations in the following categories face elevated risk from this class of attack:

  • E-commerce and fintech: Card skimming payloads directly target payment data; any Optimizely customer with checkout flows is at primary risk
  • Media and high-traffic sites: The iOS exploit kit component suggests the attacker was targeting mobile visitors at scale — media properties with large mobile audiences are ideal delivery vectors
  • Any organization loading third-party JavaScript from SaaS CDNs: This is not an Optimizely-specific problem; it is a structural weakness in how the web handles trusted script delivery

Shield53 Recommendations

Immediate Actions:

  • Audit Optimizely project configurations: Review all Project JavaScript fields across every Optimizely project in your environment for unauthorized code. Do not assume the vendor's cleanup was complete — Smartsheet's re-infection proves this assumption is unsafe.
  • Search for IOC domains: Scan proxy logs, endpoint telemetry, and CSP reports for connections to 1688360[.]cc and any base64-encoded variants referencing this domain.
  • Force credential resets: If attacker access persistence is confirmed, rotate any Optimizely API tokens, service account credentials, and SSO integrations associated with affected projects.
  • Notify payment compliance teams: If card skimming code loaded on any page touching payment flows, this may constitute a reportable PCI DSS incident — involve your QSA immediately.

Structural Defenses (Beyond This Incident):

  • Implement Subresource Integrity (SRI) on all third-party scripts: SRI won't stop a vendor-side compromise where the hash changes legitimately, but it will alert you to unauthorized script modifications in real time.
  • Deploy runtime script monitoring: Tools like Report URI or equivalent CSP report collectors should be configured to alert on unexpected script origins, new domains, and script content changes — not just CSP violations against allowlisted domains.
  • Adopt a third-party script governance policy: Every external script loaded on your site should have a documented owner, a business justification, an inventory of what data it can access, and a periodic review cadence. If you cannot answer "what does this script do and who owns it" for every script tag in your page, you have a governance gap.
  • Consider script sandboxing: Techniques like locking scripts to specific paths, using fetch()-based script loading with runtime validation, or deploying browser-side script allowlisting can reduce the blast radius of vendor compromises.

This incident is not the last supply chain compromise of a trusted SaaS script provider. The question for every security team is not whether your vendors will be compromised — it is whether your detection and response capabilities will catch the malicious code before your customers do.