178 Big Brands Served Visitors the Same Hijacked Script

The Optimizely hack (OptimJack) put card-skimming code on 178 brands' sites; here's how to check and clean up your clients' Optimizely sites.

Visitors to Zoom, the BBC and CNN were served code that swapped crypto wallet addresses, skimmed card numbers and probed iPhones, through a testing script those sites trusted. On 16 November 2026, attackers planted it in Optimizely Web Experimentation projects belonging to 178 organisations, Report URI found. Check every client site that runs Optimizely today: the code is gone, but what it took is not.

TL;DR

  • On 16 November 2026, attackers injected malicious JavaScript into Optimizely Web Experimentation projects, and Optimizely's own delivery network served it to visitors of 178 organisations, per Report URI.
  • A client is exposed if its site loaded an Optimizely snippet on 16 November; Optimizely's History page shows who changed each project's code.
  • Read each client's Optimizely change history, search saved pages and logs for the published indicators, remove unknown editors and rotate session cookies.
  • The code swapped wallet addresses, skimmed card details and served iOS exploit kits; Report URI counted about $7,040 in attacker wallets by 19:25 UTC.

What happened in the Optimizely hack and who was hit?

Attackers added malicious JavaScript to the Project JavaScript field of Optimizely Web Experimentation customer projects, so Optimizely's own servers delivered it inside each site's trusted snippet. Optimizely said "an unauthorized party exploited a vulnerability in Experimentation and used it to add malicious JavaScript to some customer projects", and that the vulnerability is fixed. Its notice gives no technical detail and names no CVE id.

Report URI found the code in 188 of the 1,611 snippets it checked, belonging to 178 organisations including Zoom, BBC, CNN, Salesforce and HSBC. Some researchers call the campaign OptimJack, per Security Affairs. It follows the same third-party JavaScript supply chain attack pattern as the hijacked page-speed script that drained Polymarket traders.

What did the Optimizely malware do?

The Optimizely malware was one script with four jobs, and Report URI found the attacker rebuilt it 26 times on 16 November 2026.

  • Wallet swapping: it replaced Bitcoin, Ethereum, TRON, Solana and other wallet addresses on the page and in the clipboard with the attacker's own.
  • Card skimming: from 13:43 UTC, a card skimmer copied card number, expiry and CVV from the site's own forms. Cards typed into hosted Stripe or Adyen payment frames were out of its reach.
  • Cookie and screenshot theft: it sent the page address, a screenshot and any cookie without the HttpOnly flag (a setting that hides a cookie from scripts) to the attacker.
  • iPhone exploits: it loaded the Coruna kit for iOS 13 to 17 and the DarkSword iOS exploit chain for iOS 18. Security Affairs reports that no compromise of a real device had been reported.

Report URI counted about $7,040 in attacker wallets by 19:25 UTC; according to Security Affairs, StepSecurity puts the figure near $6,600. The first Optimizely injection appeared at 04:21 UTC in the BBC's snippet, and Report URI says all infected files were clean by 23:11 UTC.

How do I check if my clients are exposed to the Optimizely hack?

List every client URL, login and checkout pages included, in client-urls.txt, and run the blocks in one terminal. The window starts on 17 September 2026, when Report URI dates this injector's first appearance; it also rode Kissmetrics, StorifyMe and Minute Media scripts from 13 November, which check 3 catches.

  1. Preserve evidence. Save each page and the Optimizely snippets it loads, then hash the copies. Pass: $D.sha256 holds one line per saved file.

    D="$HOME/evidence/optimizely-$(date +%Y%m%d-%H%M)"; mkdir -p "$D"
    while read -r url; do
      f="$D/$(printf '%s' "$url" | tr -c 'A-Za-z0-9' '_')"
      curl -sL --max-time 20 "$url" -o "$f.html"
      grep -oE 'cdn\.optimizely\.com/js/[0-9]+\.js' "$f.html" | sort -u |
        while read -r s; do curl -sL --max-time 20 "https://$s" -o "$f.${s##*/}"; done
    done < client-urls.txt
    sudo find "$D" -type f -exec sha256sum {} + | sudo tee "$D.sha256"
    
  2. List the clients that load Optimizely. This is the exposure check; it catches self-hosted copies, but not a snippet a tag manager adds later. Pass: no file is listed; a listed client is in scope for checks 4 and 5.

    grep -il 'optimizely' "$D"/*.html
    
  3. Search the saved copies for Report URI's indicators. The first command matches attacker domains and payload markers, the second the two published track.js hashes. Pass: both print nothing; a hit means the client served the payload, so treat it as a likely compromise and escalate.

    grep -rlE '1688360|webshell\.lol|linkforge\.cc|5vobauua3ojpklx|eil786npto9u5bq|l7bcsnwc7nzr3uo|__k7b|window\._k7' "$D"
    sudo find "$D" -type f -exec sha256sum {} + | grep -iE '814a963c0da480e2449d9b6664480156e1cd6d731014117401bf635badec3a0f|f7b84b9a94f749f8ced3f0112d0a66894e8bbc3b4aa5592021d1b8976a9bad40'
    
  4. Pull every Optimizely change since 17 September. With an Administrator token from Profile > API Access (Optimizely), this calls the change-history API across all projects; show the client the editor list. Optimizely hasn't said whether this history records edits made through the flaw. Pass: the final grep prints nothing.

    # optimizely-tokens.txt: one "<client-name> <Administrator token>" per line
    # an error object instead of a list means the token lacks access; over 100 projects needs &page=2
    A=https://api.optimizely.com/v2
    while read -r c t; do
      for p in $(curl -s -H "Authorization: Bearer $t" "$A/projects?per_page=100" | jq -r '.[].id'); do
        for pg in $(seq 1 100); do
          r=$(curl -s -H "Authorization: Bearer $t" "$A/changes?project_id=$p&start_time=2026-09-17T00:00:00Z&per_page=100&page=$pg")
          [ "$(printf '%s' "$r" | jq 'length')" -gt 0 ] || break
          printf '%s\n' "$r" > "$D/changes-$c-$p-$pg.json"
        done
      done
    done < optimizely-tokens.txt
    jq -r '.[] | [.project_id, .created, .source, .user.email] | @tsv' "$D"/changes-*.json | sort -u
    grep -lE '1688360|webshell\.lol|linkforge\.cc' "$D"/changes-*.json
    
  5. Search DNS and proxy logs. Export the client's resolver or web-proxy logs from 17 September 2026 into $D/logs. Pass: no output; a hit is contact with known attacker infrastructure, so treat it as a likely compromise and escalate. Logs starting later can't rule out contact.

    find "$D/logs" -type f -exec zgrep -hE '1688360\.cc|webshell\.lol|linkforge\.cc|5vobauua3ojpklx\.icu|eil786npto9u5bq\.icu|l7bcsnwc7nzr3uo\.icu|je4ft3gn8vxudum\.icu|q1ls1ho9x7wsxlu\.icu|ios-hack\.icu' {} +
    

How do I fix the Optimizely hack on client sites?

Optimizely says it fixed the vulnerability and removed the injected code; what remains is access, stolen data and hardening.

  1. Remove unknown editors and tokens. In Settings > Collaborators (Optimizely), remove anyone the client can't name; revoke unknown tokens under Profile > API Access. Pass: both screens list only people the client approved.

  2. Clean Project JavaScript. Under Settings > JavaScript (Optimizely), delete code the client didn't write, including atob( calls, as Report URI advises. Pass: this live check prints 0.

    while read -r url; do curl -sL --max-time 20 "$url" | grep -oE 'cdn\.optimizely\.com/js/[0-9]+\.js'; done < client-urls.txt |
      sort -u | while read -r s; do curl -sL --max-time 20 "https://$s"; done |
      grep -cE '1688360|webshell\.lol|linkforge\.cc|__k7b'
    
  3. End stolen sessions. Sign all users out server-side and set HttpOnly on session cookies; this lists cookies still missing it. Pass: no session cookie is listed.

    while read -r url; do
      curl -sIL --max-time 20 "$url" | grep -i '^set-cookie' | grep -vi 'httponly' | sed "s|^|$url |"
    done < client-urls.txt
    
  4. Keep card entry in hosted payment fields. Report URI says to treat cards typed into a site's own forms on 16 November as exposed; move entry into the provider's hosted frame, and check the store database too (skimmers hide there). Pass: no URL is printed.

    while read -r url; do
      curl -sL --max-time 20 "$url" | grep -qiE 'autocomplete="cc-(number|csc)"|name="[^"]*(card_?number|cvv|cvc)' && echo "$url"
    done < client-urls.txt
    
  5. Hardening (agree with the client first): tighten the Content Security Policy. A CSP header lists where scripts may load from and send data; Report URI found 68 affected hosts with none. Drop 'unsafe-eval' and 'strict-dynamic', tighten connect-src, test in Report-Only mode; Optimizely's docs ask for 'unsafe-eval', so experiments may break. Pass: no URL is printed.

    while read -r url; do
      csp=$(curl -sIL --max-time 20 "$url" | grep -i '^content-security-policy')
      { [ -z "$csp" ] || printf '%s' "$csp" | grep -qiE 'unsafe-eval|strict-dynamic'; } && echo "$url"
    done < client-urls.txt
    
  6. Update client-managed iPhones. Per Report URI, the kit's own code marks iOS 18.7.3 and 26.3 as patched. Pass: the client's mobile device management inventory shows no iPhone or iPad below those versions.

  7. Rerun the checks. Pass: rerunning checks 1, 3 and 4 prints no indicator hits.

Where KinoSec fits

KinoSec's autonomous web app pentest checks whether each client's site has weaknesses that let an attacker's JavaScript run, or that decide what it can take, such as a missing Content Security Policy or session cookies without HttpOnly. It tests what an attacker could reach from the outside, chains findings the way an attacker would, and writes each one up with remediation. It cannot see inside Optimizely's systems or watch a vendor's file for changes; the change-history and indicator checks cover that. The useful question for the next vendor script is how much it could take from each client's pages, and autonomous web app pentesting across all your clients is built to test for that class of weakness, in a report you hand to the client.

Frequently Asked Questions

Is the Optimizely hack the same as a Magecart attack?

Partly. Magecart-style attacks plant card-skimming JavaScript on checkout pages, and the Optimizely malware added a card skimmer at 13:43 UTC on 16 November 2026, per Report URI. It also swapped crypto wallet addresses, stole cookies and served iOS exploit kits, and it arrived through a vendor's script rather than the site's own code.

How do I check if my clients' sites served the Optimizely malware?

First, list the saved pages that load Optimizely with grep -il 'optimizely' "$D"/*.html. Second, search the saved copies for Report URI's indicators with grep -rlE '1688360|webshell\.lol' "$D"; a hit means treating it as a likely compromise and escalating. Third, pull each project's edits since 17 September 2026 from https://api.optimizely.com/v2/changes.

What if a client can't drop 'unsafe-eval' because Optimizely needs it?

Report URI notes that Optimizely's documentation tells customers to allow 'unsafe-eval', and at HSBC the payload's inline fallback ran even though its main file was blocked. A tight connect-src still stops stolen data leaving the page, though not on-page wallet swapping. Security Affairs also advises keeping third-party scripts off checkout pages.

Should clients keep A/B testing scripts on login and checkout pages?

Security Affairs advises against third-party scripts on checkout pages, and the same reasoning covers login pages. Optimizely documents a snippet integrity check that hashes the static part of the snippet, but says the changing experiment code needs change control and audit logs instead. Keep testing on pages where a hijacked script has little to steal.