azureblog.co.uk
← cd ~/posts
Azure · What's new

Malware on 178 of the world's biggest websites, through one trusted script: what happened with Optimizely, and how to protect your own site

On Monday, visitors to Zoom, the BBC, CNN, HSBC, Equifax and 173 other organisations' websites were served malware that swapped crypto addresses, skimmed card details and tried to hack iPhones. None of those companies were breached directly. The code came through Optimizely, a testing tool they all trusted. Here's what happened, and why most of their security settings didn't stop it.

AzureNEW7 min read✓ checked 17 Nov 2026What's new · Security
On this page
  1. What happened
  2. How it worked
  3. What the malware did
  4. Why most security settings didn't stop it
  5. What to do about your own site
  6. If you use Optimizely Web
  7. If you visited one of these sites on Monday
  8. The checklist
  9. Sources

On Monday 16 November, for most of the day, the websites of 178 organisations served malicious JavaScript to their visitors. The list includes Zoom, the BBC, CNN, Fox News, Salesforce, GitLab, IKEA, HSBC, Equifax, Air France-KLM, Ledger, Peacock and TalkTalk. Banks and financial firms were the biggest group, with 32 of them.

None of these companies had their own servers hacked. Every one of them used Optimizely Web, a tool for A/B testing website changes, and the malware arrived through it. That's what makes this one worth understanding even if you've never heard of Optimizely: almost every website loads code from someone else.

What happened

  1. Malware added to the first Optimizely snippet
  2. Crypto address swapping starts
  3. Card skimmer added
  4. iPhone exploit kits added
  5. Mass clean-up done
  6. Optimizely confirms the fix
Times are UTC, from Report URI's investigation and Optimizely's status page.

Days earlier, from 13 November, the same attacker had already hit sites through Kissmetrics, StorifyMe and Minute Media scripts. On Monday the attacker also moved stolen crypto out to exchanges at 13:03, and by 21:52 only TalkTalk's snippet was still infected.

The attack was found and documented by Scott Helme's team at Report URI, a company that sells tools for monitoring scripts on websites. Optimizely has confirmed it: it says "an unauthorized party exploited a vulnerability in the Experimentation account signup flow", and that it has "fixed the vulnerability and removed the injected code from affected projects."

How it worked

Sites that use Optimizely Web add one line to every page: a script loaded from cdn.optimizely.com. That script includes a Project JavaScript field, custom code the site's own team can add, which runs on every page.

The attacker got write access to customer projects and put their own code into that field. The rest of the snippet was untouched. So the malware was delivered by Optimizely's own servers, in the file every one of these sites had deliberately chosen to load.

AttackerOptimizelyCompany websiteVisitor's browserAttacker's serverExploits avulnerability andedits customerprojects1Serves the usualsnippet, now withextra code2Page loads thesnippet, which runswith the page's fullaccess3Sends cards, cookiesand screenshots4
The attack path as Report URI and Optimizely describe it. How the attacker got write access beyond the signup flow vulnerability hasn't been published.

The attacker made the loader harder to block as the day went on. One version was a plain script tag, another hid the address in base64, and a third carried the whole payload inline and ran it through eval in case the attacker's domain was blocked. They rebuilt the payload 26 times.

What the malware did

  • Swapped crypto addresses. Any Bitcoin, Ethereum, TRON, Solana or other wallet address on the page, in a form or on the clipboard was replaced with the attacker's. Pay a crypto invoice on an affected site and the money went to them.
  • Skimmed card details. From 13:43 UTC, it captured card number, expiry and CVV from payment forms built into the site. Card fields hosted by a payment provider in their own frame were out of reach.
  • Took screenshots and cookies. When wallet or payment wording was on the page, it sent the address, any cookies not marked HttpOnly and a screenshot to the attacker.
  • Tried to hack iPhones and iPads. It loaded known exploit kits in a hidden frame: Coruna for iOS 13 to 17 and DarkSword for iOS 18. On iOS 18.6 or older, the page reloaded every 60 seconds, which was the one visible sign. Report URI says iOS 18.7.3 and 26.3 or later are patched.

As of Monday evening, about $7,040 in crypto had reached the attacker's wallets, all within roughly nine hours. Nobody knows yet how many cards or cookies were taken. The headlines about "customers' money and credit card details" are fair, but the confirmed losses so far are small. The real exposure is card data typed into sites' own payment forms that day, and iPhones that hadn't been updated.

Why most security settings didn't stop it

The defence built for exactly this is a Content Security Policy (CSP): a header that tells the browser which sources a page may load scripts from and send data to. Report URI checked the affected organisations' sites:

What their policy didOrganisations
No Content Security Policy at all68
Let the malware run and send data out50
Let the malware run, but stopped it sending data out17
Blocked the malware completely24 (15%)

Three findings stand out:

  • Allowing the vendor's domain gave no protection. Most policies list cdn.optimizely.com as an allowed script source. That's where the malware came from, so it sailed through.
  • 'unsafe-eval' let the backup copy run. HSBC's policy blocked the attacker's domain, but allowed eval, so the inline fallback ran anyway. Optimizely's own documentation recommends a setting that needs it.
  • connect-src was the setting that saved data. Sites that limited where the page could send requests stopped the card, cookie and screenshot theft, even where the payload ran. It didn't stop address swapping, which happens inside the page.

What to do about your own site

This wasn't an Optimizely-only problem. The same attacker had already used Kissmetrics, StorifyMe and Minute Media scripts days before. Any third-party script you load (analytics, chat, tag managers, A/B testing, consent banners) runs with the same power as your own code.

1. Know what's loading

List every third-party script on your pages, who owns each one, and whether you still need it. Remove the ones you don't. Every script is another company whose security you're relying on.

2. Lock down where the page can send data

Start with connect-src. It's the setting that stopped the theft here, and it's usually the easiest to get right because you know which APIs your site calls. A starting point:

text7 lines
Content-Security-Policy:
  default-src 'self';
  script-src 'self' https://cdn.optimizely.com;
  connect-src 'self' https://logx.optimizely.com https://api.yourpayments.example;
  frame-src https://js.yourpayments.example;
  object-src 'none';
  base-uri 'self'

Adjust the hosts to what your site really uses, and deploy it as Content-Security-Policy-Report-Only first so you can see what would break before you enforce it.

3. Don't allow 'unsafe-eval' unless you've no choice

It turned a blocked attack into a working one at HSBC. If a vendor tells you to allow it, ask what feature needs it and whether you can live without that feature.

4. Keep card details out of your own forms

Card fields hosted by a payment provider in its own frame (Stripe Elements, Adyen and others) were out of reach. Fields built into the site's own form were skimmed. If you take payments, use the hosted fields.

5. Mark cookies HttpOnly

The malware could only take cookies that page scripts can read. Session cookies should always be HttpOnly, Secure and SameSite.

6. Watch for changes

Turn on CSP reporting so the browser tells you when something tries to break the rules. Report URI found this attack by noticing changes to scripts across many sites, and you can do the same for yours, either with a commercial service or by regularly comparing the third-party files you load against a known-good copy. For scripts that don't change, Subresource Integrity (an integrity hash on the script tag) makes the browser refuse a modified file. It doesn't work for scripts like Optimizely's, which change every time you edit an experiment.

7. Protect the accounts behind your vendors

Anyone who can edit your tag manager, A/B testing or analytics account can put code on your site. Give those accounts , single sign-on where it's offered, and as few editors as possible, and review who has access.

If you use Optimizely Web

  • Check your Project JavaScript and experiment code for anything you didn't add, especially 1688360.cc, atob( or unknown script URLs.
  • Review and rotate credentials and API tokens with write access to your projects.
  • Treat card details typed into your own forms on 16 November, and any cookies not marked HttpOnly, as potentially exposed.
  • Check Optimizely's notification and status page for guidance specific to your account.

If you visited one of these sites on Monday

  • Update your iPhone or iPad: iOS 18.7.3 or later, or iOS 26.3 or later.
  • Check your card statements if you paid on an affected site that day.
  • Always double-check a crypto address after you paste it, especially before large payments.

The checklist

  1. List every third-party script on your site and remove the ones you don't need.
  2. Deploy a Content Security Policy in mode, then enforce it, starting with connect-src.
  3. Remove 'unsafe-eval' wherever you can.
  4. Use your payment provider's hosted card fields.
  5. Make session cookies HttpOnly, Secure and SameSite.
  6. Turn on CSP reporting, and add Subresource Integrity to scripts that don't change.
  7. Protect and review the accounts that can edit your tag manager, analytics and testing tools.

Optimizely hasn't yet published a full account of the vulnerability. This post will be updated when it does.

Sources

More on Security →

Spotted something out of date or wrong? Tell us and we'll fix it.