Skip to content
A-Line

Back to news

Protect client sites from hacked third-party scripts

By Published 14 min read

On this page

You build and run client sites, and their marketing teams add analytics, A/B testing, chat and consent widgets, often through a tag manager and without asking you. On 16 November 2026 one of those vendors, Optimizely, served attacker code to its customers’ visitors, where it ran with the same access as the page’s own scripts. Many affected sites had a Content Security Policy that allowed Optimizely’s domain. It didn’t help, because the code came from that domain. This piece shows which defence stopped which step of the attack in three browsers, and what to change on client sites.

In short

Allowing a vendor’s domain decides where code may load from. It says nothing about what that code does once it runs. When the vendor itself is compromised, four things protect your visitors: keep outside scripts off checkout and login pages, take card entry in the payment provider’s hosted iframe, limit where the page may send data (default-src ‘self’ plus connect-src, img-src and form-action), and notice a changed vendor script within hours.

What happened at Optimizely, as of 18 November 2026

According to Report URI, the code injected into Optimizely snippets on 16 November swapped crypto wallet addresses on the page, read card fields typed into a site’s own form, sent non-HttpOnly cookies and a screenshot of the page to the attacker’s domain, and on iPhones and iPads loaded iOS exploit kits (Report URI, 2026-11-16). Report URI (Scott Helme), which sells CSP monitoring, found the malicious code in 188 of the 1,611 Optimizely snippets it checked, across 178 organisations.

Optimizely says an unauthorized party exploited a vulnerability in its Experimentation account signup flow to add malicious JavaScript to some customer projects, and that it has removed the injected code (status page, 2026-11-17; BleepingComputer, 2026-11-17). It has not yet published a root-cause report.

The figure shows the day as Report URI and StepSecurity, which sells software supply-chain security tools, recorded it. StepSecurity puts the exposure window for most sites at about 16 hours (StepSecurity, 2026-11-17).

16 November 2026, in UTCFrom the first infected snippet Report URI saw to the last one cleaned, with the times as each source published them.
  • Attack
  • Clean-up, some still infected
  • Recorded moment
  • Optimizely snippets: Attack, 04:21 to 20:40 UTC; Clean-up, some still infected, 20:40 to 23:11 UTC
  • Attacker's domain: Attack, at 05:23 UTC; Recorded moment, at 08:28 UTC
  • Payload, track.js: Attack, 08:10 to 17:56 UTC; Attack, at 17:56 UTC
  1. 04:21First injection seen, in the BBC's snippet (Report URI)
  2. 05:23The attacker's domain, 1688360.cc, registered (StepSecurity)
  3. 08:10First build of the payload file, track.js (Report URI)
  4. 08:28First public scan records a request to that domain (StepSecurity)
  5. 17:56Final payload live, served with cache-control: max-age=15 (StepSecurity)
  6. ~20:40Mass clean-up, to about 21:10 (StepSecurity)
  7. 21:52One snippet still infected, down from 169 at 20:56 (Report URI)
  8. 23:11All infected Optimizely files clean (Report URI)

No source counts the affected visitors, and no estimate of the attacker’s takings is confirmed.

Check whether a client site was affected

A client site was exposed if it loaded the snippet of an infected Optimizely project between 04:21 and 23:11 UTC on 16 November, even if the project looks clean today.

  1. Find every client site that loads an Optimizely Web snippet, including copies served from the client’s own domain, which Report URI found “were affected too, because the content comes from the same Optimizely project”.
  2. Read each project’s Project JavaScript, where the attacker wrote its code, and every experiment’s custom code. Searching for 1688360.cc isn’t enough: one variant hid it in base64 behind atob( (Report URI). This shows only today’s state.
  3. For 16 November itself, search that day’s CSP reports for every host in Report URI’s indicator list. An earlier wave injected webshell.lol through Kissmetrics, StorifyMe and Minute Media scripts, so for sites that load those, search from 13 November.
  4. Review who and what can publish in the project, and rotate the credentials. Report URI saw one snippet re-infected after it had been cleaned.

If anything turns up, follow the first 24 hours after a vendor compromise.

Why allowing the vendor’s domain didn’t help

A host allowlist checks where a script loads from, so it can’t help when the trusted host serves the attack. Report URI: “What separated the 24 protected sites from the rest was a restrictive script-src.” The chart shows how it sorted 159 of the affected organisations.

159 affected organisations, by what their CSP allowedReport URI's crawl of the organisations' own hosts. For the 17, connect-src blocked the theft, but the address swap still worked; the 15% is a share of these 159. Report URI, 2026-11-16
  • Theft allowed
  • Payload ran, theft blocked
  • Payload blocked
  • No CSP 68
  • Payload and theft allowed 50
  • Payload ran, theft blocked 17
  • Payload blocked 24 (15%)
Show the numbers as a table
ResultOrganisations
No CSP68
Payload and theft allowed50
Payload ran, theft blocked17
Payload blocked24 (15%)

The other common strict policy fails too. It puts a nonce (a random value the server sends fresh with every page) on each trusted script tag, and adds 'strict-dynamic', which, as StepSecurity puts it, “trusts scripts that a trusted script adds”. Optimizely’s own CSP documentation recommends it.

Its version archived on 9 October 2026 also asked for 'unsafe-eval', which lets scripts turn a string into code, for “audiences with custom JavaScript conditions” (archived copy). At HSBC, Report URI reports, that let a copy of the payload inside the snippet run through eval() while the site’s CSP blocked the attacker’s remote script. The live version of 17 November no longer asks for it.

What we tested: which defence stops which step

In the lab, limiting where the page may send data stopped every channel of theft, but nothing stopped the page being rewritten once the payload ran. The table shows which defence stopped which step.

In the harmless lab, a changed vendor snippet holds a loader, the part that adds the attacker’s script, and a stand-in payload swaps a wallet address, reads the card field and cookies, and sends them out four ways. “Data limits” means default-src 'self' with connect-src, img-src and usually form-action set to the site. The built-in copy is a copy of the payload inside the vendor file, which runs when the attacker’s host is refused.

Which attack step still worked, by defenceLab run, 18 November 2026, in Chromium, Firefox and WebKit. A filled dot means the step worked; a half dot, that only the built-in copy got that far.
DefencePayload ranAddress swappedCard readReached the attacker
No CSPYesYesYesYes
Nonce onlywith 'strict-dynamic', no data limitsYesYesYesYes
Data limitson a nonce + 'strict-dynamic' policyYesYesYesNo
Host allowlist, hash or Trusted Typeswith data limitsOnly the built-in copyOnly the built-in copyOnly the built-in copyNo
Card in the payment iframenonce + data limitsYesYesNoNo
SRI pinned, file changedNoNoNoNo
No vendor script on the pageNoNoNoNo
Report-onlyany CSP that loaded the vendor scriptYesYesYes, not the iframe cardYes

One policy under test, with 'unsafe-eval' as Optimizely’s docs once asked:

default-src 'self';
script-src 'nonce-{RANDOM}' 'strict-dynamic' 'unsafe-eval';
connect-src 'self';
img-src 'self';
form-action 'self';
frame-src https://pay.test;

These are three of the six errors in the Chromium console:

error: Connecting to 'https://evil.test/collect?via=fetch' violates the following Content Security Policy directive: "connect-src 'self'". The action has been blocked.
error: Connecting to 'https://evil.test/beacon' violates the following Content Security Policy directive: "connect-src 'self'". The action has been blocked.
error: Sending form data to 'https://evil.test/formpost' violates the following Content Security Policy directive: "form-action 'self'". The request has been blocked.

In that run, the attacker’s server logged nothing. The wallet address was still swapped and the card field read, because both happen inside the page.

In the figure, pick the defence you think keeps the card number in, then turn defences on and off and watch which steps still work.

Which step still works?

Predict first. Then turn defences on and off and watch each step of the attack.

Which one defence do you think stops the card number leaving the page?

Where the attacker put the payload
Which scripts may run
Also in the policy
On the page

The lab didn't run this combination, and the figure doesn't guess. Change a setting back, or pick a lab setup.The lab ran Trusted Types only on top of nonce + 'strict-dynamic', with 'unsafe-eval' allowed and data limits, so it has no result for this combination.

How far the attack got in each lab setup:

  • Not stopped: data reached the attacker's host

    • No CSP
    • Nonce + 'strict-dynamic' only
    • Report-only version of a CSP row that loaded the vendor script
    • Report-only, card in the payment iframe
  • Stopped at step 7, sending: nothing reached the attacker's host, but the payload still ran and swapped the address

    • Nonce + 'strict-dynamic', data limits
    • Nonce + 'strict-dynamic' + 'unsafe-eval', data limits
    • Nonce + 'strict-dynamic' + 'unsafe-eval', data limits, Trusted Types, built-in copy
    • Host allowlist, data limits, built-in copy
    • Hash-pinned loader, data limits, built-in copy
    • Card in the payment iframe, nonce + 'strict-dynamic', data limits
  • Stopped at steps 2 and 3: neither copy of the payload ran

    • Nonce + 'strict-dynamic' + 'unsafe-eval', data limits, Trusted Types, payload on the attacker's host
    • Host allowlist, data limits, payload on the attacker's host
    • Hash-pinned loader, data limits, payload on the attacker's host
  • Stopped at step 1: the vendor snippet didn't run, or wasn't on the page

    • SRI pinned, file changed (host allowlist, data limits, built-in copy)
    • No vendor script on the page (script-src 'self', data limits)
  1. No CSP

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hostran
    3. Fallback copy runsnot needed
    4. Wallet address on the page is swappedran
    5. Card field on the page is readran
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: arrivedsendBeacon: arrivedimage pixel: arrivedform post: arrivedran
  2. Nonce + 'strict-dynamic' only

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hostran
    3. Fallback copy runsnot needed
    4. Wallet address on the page is swappedran
    5. Card field on the page is readran
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: arrivedsendBeacon: arrivedimage pixel: arrivedform post: arrivedran
  3. Nonce + 'strict-dynamic', data limits

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hostran
    3. Fallback copy runsnot needed
    4. Wallet address on the page is swappedran
    5. Card field on the page is readran
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  4. Nonce + 'strict-dynamic' + 'unsafe-eval', data limits

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hostran
    3. Fallback copy runsnot needed
    4. Wallet address on the page is swappedran
    5. Card field on the page is readran
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  5. Nonce + 'strict-dynamic' + 'unsafe-eval', data limits, Trusted Types, payload on the attacker's host

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hoststopped
    3. Fallback copy runsstopped
    4. Wallet address on the page is swappedstopped
    5. Card field on the page is readstopped
    6. Ordinary cookie is readHttpOnly cookie: not visiblestopped
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  6. Nonce + 'strict-dynamic' + 'unsafe-eval', data limits, Trusted Types, built-in copy

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hoststopped
    3. Fallback copy runsran
    4. Wallet address on the page is swappedran
    5. Card field on the page is readran
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  7. Host allowlist, data limits, payload on the attacker's host

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hoststopped
    3. Fallback copy runsstopped
    4. Wallet address on the page is swappedstopped
    5. Card field on the page is readstopped
    6. Ordinary cookie is readHttpOnly cookie: not visiblestopped
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  8. Host allowlist, data limits, built-in copy

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hoststopped
    3. Fallback copy runsran
    4. Wallet address on the page is swappedran
    5. Card field on the page is readran
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  9. Hash-pinned loader, data limits, payload on the attacker's host

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hoststopped
    3. Fallback copy runsstopped
    4. Wallet address on the page is swappedstopped
    5. Card field on the page is readstopped
    6. Ordinary cookie is readHttpOnly cookie: not visiblestopped
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  10. Hash-pinned loader, data limits, built-in copy

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hoststopped
    3. Fallback copy runsran
    4. Wallet address on the page is swappedran
    5. Card field on the page is readran
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  11. SRI pinned, file changed (host allowlist, data limits, built-in copy)

    1. Vendor snippet runsstopped
    2. Payload loads from the attacker's hoststopped
    3. Fallback copy runsstopped
    4. Wallet address on the page is swappedstopped
    5. Card field on the page is readstopped
    6. Ordinary cookie is readHttpOnly cookie: not visiblestopped
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  12. Card in the payment iframe, nonce + 'strict-dynamic', data limits

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hostran
    3. Fallback copy runsnot needed
    4. Wallet address on the page is swappedran
    5. Card field on the page is readThe card is in the payment provider's iframe, which the payload couldn't read.not on the page
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  13. No vendor script on the page (script-src 'self', data limits)

    1. Vendor snippet runsnot on the page
    2. Payload loads from the attacker's hoststopped
    3. Fallback copy runsstopped
    4. Wallet address on the page is swappedstopped
    5. Card field on the page is readstopped
    6. Ordinary cookie is readHttpOnly cookie: not visiblestopped
    7. Data is sent to the attacker's hostfetch: didn't arrivesendBeacon: didn't arriveimage pixel: didn't arriveform post: didn't arrivestopped
  14. Report-only version of a CSP row that loaded the vendor script

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hostran
    3. Fallback copy runsnot needed
    4. Wallet address on the page is swappedran
    5. Card field on the page is readran
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: arrivedsendBeacon: arrivedimage pixel: arrivedform post: arrivedran
  15. Report-only, card in the payment iframe

    1. Vendor snippet runsran
    2. Payload loads from the attacker's hostran
    3. Fallback copy runsnot needed
    4. Wallet address on the page is swappedran
    5. Card field on the page is readThe card is in the payment provider's iframe, which the payload couldn't read.not on the page
    6. Ordinary cookie is readHttpOnly cookie: not visibleran
    7. Data is sent to the attacker's hostfetch: arrivedsendBeacon: arrivedimage pixel: arrivedform post: arrivedran

Lab run, 18 November 2026, Chromium, Firefox and WebKit as bundled with Playwright 1.64.1, two passes.

Step 1: list every script on each client site

You can only defend what you know runs on a page. For each script on each client site, write down where it loads from, who added it and with which tool, which pages it runs on, what it can reach, why it is there, and which accounts can change it. PCI DSS Requirement 6.4.3 asks for this inventory on payment pages, with a written reason for each script, and it became mandatory after 31 March 2025 (PCI DSS v4.0, in SAQ A-EP).

A report-only CSP finds the scripts that other scripts load: the browser reports what the policy would have blocked, and blocks nothing. The lab’s report-only header for the host allowlist:

content-security-policy-report-only: default-src 'self'; script-src 'self' https://cdn.vendor.test; img-src 'self' https://cdn.vendor.test; connect-src 'self'; frame-src https://pay.test; report-uri https://shop.test/__cspreport;

Step 2: keep outside scripts off checkout and login pages

A script that doesn’t run on the checkout page can’t skim it. The ICO made the same point about Ticketmaster, where a chat bot on the payment page was the way in: not supporting it there “would have removed the risk of the attack vector being deployed” (ICO penalty notice, 2020, archived).

Where you can, give checkout and login their own subdomain, such as pay.example.be, with a stricter CSP and only the scripts those pages need. In a tag manager, set the triggers so that no marketing tag fires on checkout or login. The same goes for a page whose form takes personal data: a script on that page can read the name, address and email fields.

Step 3: take card entry in the payment provider’s iframe

A card typed into a field the payment provider hosts, in its own cross-origin iframe, is out of reach of a script on your page. In the incident, “cards entered in hosted payment iframes (Stripe, Adyen and similar) were out of its reach” (Report URI). The name, address and email fields stay in reach.

SAQ A is the self-assessment for merchants that fully outsource card data to third parties validated as PCI DSS compliant. Since 31 March 2025 it drops Requirements 6.4.3 and 11.6.1 for a page that embeds the provider’s payment iframe, and adds an eligibility criterion about script attacks (PCI SSC blog, January 2025). The merchant can meet it with its own techniques or with its payment provider’s confirmation that its solution protects the merchant’s payment page from script attacks (PCI SSC FAQ 1588).

Step 4: limit where the page can send data

A card number read inside the page only hurts the visitor once it leaves. In the lab, connect-src, img-src and form-action, each set to 'self' on top of default-src 'self', refused all four channels to the attacker’s host. Keep default-src: a policy without it “cannot mitigate exfiltration” (CSP Level 3, §8.6). List form-action on its own too, because default-src is a fallback for fetch directives only and form-action is a navigation directive (§6.1 and §6.4; the lab didn’t test this separately).

On a static or cached site the HTML usually can’t carry a fresh nonce, so web.dev recommends a hash-based policy (web.dev). Leave out its 'strict-dynamic': with it, the hashed loader may add any script; without it, the hashed loader blocked the attacker’s remote script in the lab. A hash covers only the exact inline script it was computed from (§6.7.3.3), so a vendor file from another host needs its own host or integrity entry.

Step 5: notice a changed script within hours

A skimmer collects data until someone notices it, and the final payload was served with cache-control: max-age=15, so the operator could swap it within seconds. PCI DSS Requirement 11.6.1 asks for change and tamper detection on payment pages “at least once every seven days”, or as often as a targeted risk analysis sets (PCI DSS v4.0, in SAQ A-EP; we could not check v4.0.1). A weekly check could have missed this whole attack, so check far more often.

CSP reporting is the alarm you already have: watch for a vendor script that loads from a new host or connects somewhere new. You can also compare the vendor files on a schedule, alerting on new hosts and new code that calls out, since experiment snippets change on every publish. Because the attacker’s loader sat in the vendor snippet, which every visitor received, a comparison would have caught this change, though a checker that renders the page as a desktop browser would have missed the iOS exploit requests, made only for iPhones and iPads (Report URI; StepSecurity).

Shrink what a running script can reach

Mark session cookies HttpOnly: in every lab run, the HttpOnly cookie never appeared in document.cookie, and Hudson Rock says the incident code “does not show extraction of HttpOnly cookies” (Hudson Rock, 2026-11-17).

Trusted Types (require-trusted-types-for 'script') makes the browser refuse to turn a plain string into code or a script address (MDN). Every major browser has supported it since 24 February 2026. In the lab it stopped the loader, so the remote payload never loaded, but the built-in copy still ran. And Optimizely tells customers to leave it off, “because Optimizely Experimentation cannot apply experiment changes without this ability” (Optimizely CSP guidance).

Treat the tag manager and vendor dashboards as production access

Whoever can publish a tag can run code on your visitors. Require two-factor sign-in on those accounts, remove old users and API tokens, and review each new tag before it goes live. Ask each vendor whether it has a server-side option that keeps its code out of the visitor’s browser.

That may not be enough: Optimizely says the signup flaw let the attacker impersonate users on targeted customer accounts, but as of 18 November it has not published how (status page, 2026-11-18). Steps 2 to 5 still work when the vendor is the one that fails.

When a vendor you use is compromised: the first 24 hours

  1. Remove or disable the vendor’s tag, as Salesforce (2026-11-17) and Zoom (retrieved 2026-11-18) say they did with Optimizely, and check that the page no longer loads it.
  2. Check each client’s projects as in checking whether a client site was affected.
  3. Keep the evidence: CSP reports, server logs and any urlscan.io captures.
  4. Find out, per site, when the tag was live and which pages it ran on.
  5. Rotate the vendor project’s tokens and credentials.
  6. Tell the client in writing. Under the GDPR the client is usually the controller and you the processor, who must tell the controller “without undue delay” (GDPR Article 33).
  7. Help the client decide whether to notify the supervisory authority, which is due “without undue delay and, where feasible, not later than 72 hours after having become aware of it” unless the breach is unlikely to risk people’s rights. In Belgium that goes through the Data Protection Authority’s portal, not by email (GBA, in Dutch).

What these defences don’t cover

None of this makes a permitted script safe: the figure shows what each step leaves. A script you allow can still rewrite your page, from a wallet address to a price. Only stopping it from running prevents that, which is why “Step 2: keep outside scripts off checkout and login pages” matters most.

What each step stops, and what it leaves
  • Step 1: list every script

    • Stops

      Nothing on its own. It shows what runs and who can change it.

    • Still works

      Everything: in every report-only run that loaded the vendor script, the data reached the attacker.

  • Step 2: keep scripts off checkout and login

    • Stops

      Everything on those pages: with no vendor script, nothing ran in the lab.

    • Still works

      The attack on every page where the script still loads.

  • Step 3: card in the provider's iframe

    • Stops

      Reading the card: the payload read null in all three browsers.

    • Still works

      Reading the name, address and email fields, and rewriting the page, such as the wallet-address swap.

  • Step 4: limit where data goes

    • Stops

      In the lab, all four channels to the attacker's host.

    • Still works

      Everything inside the page: the address swap and reading the site's own card field.

  • Step 5: notice within hours

    • Stops

      Nothing. It shortens how long a skimmer collects.

    • Still works

      The attack itself: monitoring only tells you once it has started.

A restrictive CSP breaks marketing tools that expect to inject freely, and a busy tag manager means changing the policy with it.

The questions below show which steps a client site needs.

Which steps a client site needsSteps 1 to 5 are the numbered sections above. On every site, treat the tag manager and vendor accounts as production access.
  1. Question 1: Does the site have a login, a form that takes personal data, or payments?

    • NoLittle for a skimmer to take, but the script still runs for every visitor: on 16 November it loaded iOS exploit kits on iPhones and iPads. Steps 1, 4 and 5.
    • YesNext question.
  2. Question 2: Do marketing tags reach the site through a tag manager?

    • YesSet its triggers so that no marketing tag fires on checkout, login or a page with such a form (step 2). Next question.
    • NoNext question.
  3. Question 3: Does the site take payments?

    • NoSteps 1, 4 and 5, and step 2 for login pages and pages with such a form. Step 3 is for card entry.
    • YesKeep A/B testing tools off checkout too, above all one that needs 'unsafe-eval' or rules out Trusted Types. Next question.
  4. Question 4: Is the card number typed on your own page, rather than in the payment provider's iframe?

    • YesSteps 1 to 5. A running script reads a card typed into your own field; step 3 moves card entry into the provider's iframe, out of its reach.
    • NoSteps 1, 2, 4 and 5. With the card in the provider's iframe, step 3 is in place; a merchant that validates with SAQ A still has to meet its criterion about script attacks (step 3).

Frequently asked questions

Would SRI have stopped this?

No, not for the Optimizely snippet. Subresource Integrity (SRI) pins a file’s hash, and in the lab it refused the changed file in all three browsers. But Optimizely says “you cannot check the dynamic code effectively with a simple hash comparison because the code changes constantly” (Optimizely). Use SRI for libraries that don’t change.

Should I self-host the Optimizely script?

It would not have helped here: customers serving the snippet from their own domain were affected too (Report URI). Unless a person reviews each change before it goes live, a sync job copies a poisoned file as quickly as a clean one.

Does a CSP stop a crypto clipper (a wallet-address swap)?

Not once the code runs, because the swap needs no outbound request.

Was an iPhone that visited an affected site hacked?

Nobody has shown that. Hudson Rock, which sells infostealer intelligence, calls its iOS findings “delivery observations, not demonstrated iPhone compromises” (Hudson Rock, 2026-11-16).

Where to start

Open the checkout page of one client site that takes payments. List the outside scripts that load there, and who can change each one. Move the first one that doesn’t need to be there: a script that isn’t on the page can’t rewrite it.

How this was tested

The lab is a local HTTPS server with four origins: the shop, the vendor CDN, the attacker’s host and a cross-origin payment page. The stand-in payload runs the steps a skimmer runs: swap the wallet address, read the page’s own card field, try the payment iframe, read cookies, and send what it gathered four ways (fetch, sendBeacon, an image pixel and a form post). The real payload is not reproduced; the steps are modelled with fake data. Runs were on 18 November 2026 in the Chromium, Firefox and WebKit builds bundled with Playwright 1.64.1, in two passes with the same outcome in every column.

Each policy ran against two versions of the fallback copy. In the first, the loader fetches the payload from the attacker’s host and, if that fails, runs a copy through eval(). In the second, the copy is built into the vendor file as ordinary code and needs no eval(): the built-in copy. Every table row except the first two had data limits, and the host allowlist rows also allowed images from the vendor’s host. A hash-pinned loader means script-src lists only the hash of one inline loader script, with no 'strict-dynamic'. The lab pinned the loader as the attacker had already changed it, to test what a hash does with the scripts that loader adds; that is why the built-in copy ran there. The attacker server’s log is the record of what left the page, because sendBeacon reported success in Chromium and WebKit even when CSP had blocked the request.

Lab policy Payload ran Address swapped Card read Reached attacker
No CSP yes yes yes yes
Nonce + 'strict-dynamic' only yes yes yes yes
Nonce + 'strict-dynamic' + 'unsafe-eval', data limits yes yes yes no
Host allowlist, data limits, payload on the attacker’s host no no no no
Host allowlist, data limits, built-in copy yes yes yes no
Hash-pinned loader, data limits, payload on the attacker’s host no no no no
Hash-pinned loader, data limits, built-in copy yes yes yes no
Nonce row above + Trusted Types, payload on the attacker’s host no no no no
Nonce row above + Trusted Types, built-in copy yes yes yes no
Card in the payment iframe, nonce + data limits yes yes no no
SRI pinned, file changed no no no no
No vendor script on the page no no no no
Report-only version of any CSP row that loaded the vendor script yes yes yes (no for the iframe) yes

Report URI’s organisation counts come from a crawl of 256 of the affected organisations’ own hosts. They cover 159 organisations, so the 15% is a share of those 159 (our arithmetic), not of all 178. Help Net Security repeats Report URI’s figures, quoting Helme, so it is not an independent check (Help Net Security, 2026-11-17). Estimates of what the attacker received: about $7,040 as of 19:25 UTC on 16 November, later about $7,150 (Report URI; Help Net Security reports the same), and about $2,300 sent by victims (Alex Thorn of Galaxy Digital, as reported by StepSecurity, which could not confirm it). Report URI: “We have no way to see how many credit cards were skimmed”.

The timeline as published, in UTC. Amirul Cyber named the campaign OPTIMJACK (Amirul Cyber, 2026-11-16); StepSecurity checked “the public scan records, DNS and WHOIS”.

Time (UTC, 16 Nov) What was recorded Source
04:21 First injection seen in an Optimizely snippet (the BBC’s, loading a script from webshell.lol), after a clean capture at 02:21 Report URI
05:23 The attacker’s domain, 1688360.cc, was registered StepSecurity
08:10 First build of the payload file, track.js Report URI
08:28 The first public scan recorded a request to that domain StepSecurity
17:56 The final payload went live, served with cache-control: max-age=15 StepSecurity
~20:40 to 21:10 Mass clean-up across the infected snippets StepSecurity
21:52 One snippet was still infected, down from 169 at 20:56 Report URI
23:11 All infected Optimizely files clean Report URI

Sources were fetched on 18 November 2026. Three are security vendors: Report URI sells CSP monitoring, so it has a commercial interest in the CSP lesson; StepSecurity sells software supply-chain security tools; Hudson Rock sells infostealer intelligence. The lab results are our own.