On 16 November 2026 an attacker added JavaScript to Optimizely Web Experimentation projects. Report URI found it in 188 of the 1,611 Optimizely snippets it examined, used by 178 organisations, among them the BBC, Zoom, Salesforce and Ledger. Optimizely says the way in was a vulnerability in its Experimentation account signup flow; it has fixed it and removed the code.

The payload was mostly a clipper. It scanned the page for Bitcoin, Ethereum, Tron, Solana and TON addresses and replaced them, and it rewrote addresses copied to the clipboard. Later in the day a card skimmer was added for card fields in sites' own forms (hosted payment iframes stayed out of reach). The attacker's wallets received about $7,150, according to Report URI.

Two practical points come out of it for developers, one for users of your app and one for your pages.

Point 1: a valid checksum proves nothing about intent

Address formats with a checksum catch typos. A clipper doesn't make typos: it pastes a real address the attacker controls, so the checksum passes. Clippers also tend to use addresses whose first and last characters match the victim's, because that's what people glance at.

The only check that catches a substitution is comparing every character of what was pasted against what the user meant to paste. Here is a small, dependency-free script that does that and validates TRON addresses (Base58Check) on the side.

// addr-diff.mjs (Node 18+, no dependencies) // usage: node addr-diff.mjs <intended> <pasted> | node addr-diff.mjs --demo import { createHash } from 'node:crypto'; const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'; function base58decode(s) { let n = 0n; for (const ch of s) { const v = ALPHABET.indexOf(ch); if (v < 0) throw new Error(`not base58: "${ch}"`); n = n * 58n + BigInt(v); } const bytes = []; while (n > 0n) { bytes.unshift(Number(n % 256n)); n /= 256n; } for (const ch of s) { if (ch !== '1') break; bytes.unshift(0); } return Uint8Array.from(bytes); } const sha256 = (b) => createHash('sha256').update(b).digest(); // TRON: 0x41 version byte + 20-byte account id + 4-byte checksum, Base58 encoded. function checkTron(addr) { if (!/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(addr)) return 'wrong shape for a TRON address'; const raw = base58decode(addr); if (raw.length !== 25 || raw[0] !== 0x41) return 'wrong length or version byte'; const sum = sha256(sha256(raw.subarray(0, 21))).subarray(0, 4); return Buffer.compare(sum, Buffer.from(raw.subarray(21))) === 0 ? null : 'checksum fails'; } // EVM: shape only (EIP-55 needs keccak-256, which node:crypto does not ship). const checkEvm = (a) => (/^0x[0-9a-fA-F]{40}$/.test(a) ? null : 'wrong shape for an EVM address'); function validate(addr) { if (addr.startsWith('T')) return checkTron(addr); if (addr.startsWith('0x')) return checkEvm(addr); return 'unknown format (this script knows TRON and EVM)'; } export function diff(intended, pasted) { const out = { same: intended === pasted, positions: [] }; const len = Math.max(intended.length, pasted.length); for (let i = 0; i < len; i++) if (intended[i] !== pasted[i]) out.positions.push(i); out.headTailMatch = intended.slice(0, 4) === pasted.slice(0, 4) && intended.slice(-4) === pasted.slice(-4); return out; } 

The full file, with the report printer and a --demo mode, is about 90 lines. The demo output:

# same ends, swapped middle (what a careful clipper aims for) intended THi1gK4S738eWhMTjkezog3tPKgFaoNgLW valid format pasted THi1RgJ7UkAt8Qrby49jTmctTQjSLFNgLW INVALID: checksum fails ^^^^^^^^^^^^^^^^^^^ ^^^^^^ result DIFFERENT at 25 of 34 positions warning first 4 and last 4 characters match: a glance at the ends would miss this 

My spliced example fails the checksum because I built it by cutting two addresses together. An attacker who generates a real address with matching ends gets valid format on both lines, and the diff is what's left to flag it. In a UI, that means keeping the address the user meant (from a QR scan, a saved contact, or a second field they type into) and showing the diff before the send button, instead of only validating the pasted string.

Point 2: a snippet you can't hash doesn't belong next to an address

Subresource Integrity (integrity="sha384-...") pins a script to an exact file. It works for a library version you ship. It doesn't work for an experimentation snippet, whose contents change every time someone edits a test in the vendor's dashboard. That is the property the attacker used: the sites served the code from a trusted vendor URL without any breach of their own servers.

For pages that display a deposit address or accept a payout address, the low-effort options are:

  • Don't load experimentation, tag-manager or chat snippets on those routes at all.
  • Set a Content-Security-Policy for those routes with an explicit script-src that lists only your own origin, plus a report-uri/report-to endpoint so you see when something else tries to load.
  • If you have to run a test there, run it server side, where the variant is code you deployed.

Report URI's advice to site operators after this incident was to review custom code in their Optimizely projects and rotate credentials. Users who copied an address on an affected site on 16 November should check where their transfer went.

Sources: Decrypt, "Optimizely Hack Hijacked Ledger, BBC and 176 Other Sites to Swap Crypto Wallet Addresses" (17 Nov 2026); Cointelegraph, "Hackers inject credit card, crypto-stealing malware into 178 major websites" (17 Nov 2026, updated 18 Nov).