Zero trust lessons from x.cpe and Optimizely
The x.cpe backdoor and the Optimizely injection both worked because something was trusted for where it came from: a box inside the network, a script from an allowlisted CDN. Neither attack used AI, but AI tools are cutting the time from patch to exploit, and residential proxies fed by botnets hide automated abuse. Zero trust answers both by checking identity, device and behaviour on every request and limiting what any trusted piece can change.

At 00:37 UTC on 16 November 2026, someone created an account through Optimizely's signup flow. A flaw there let them act as administrators of other companies' accounts, after guessing employee email addresses up to thousands of times per customer. They then added a card-skimmer loader to the Optimizely code that Zoom, the BBC and HSBC run on their websites. No password was stolen. Zero trust exists to close exactly that gap.
On 2 November, Google said it had cut off the servers behind XCPE, a botnet of more than 1.3 million Android TV boxes. Its backdoor, x.cpe, was not something owners installed. Google says the boxes' own manufacturer, Videostrong, built it into the firmware and sold access to criminals.
The two attacks share one mistake. A script was trusted because it came from a CDN on the allowlist. A box was trusted because it sat inside the home or office network, and some of the boxes had passed Google's certification tests. Nobody checked either decision again.
Three days after the Optimizely attack, we re-checked the websites of all 178 organisations on the researchers' list of victims. Not one of the 215 home pages we could fetch would have blocked every version of the attacker's loader. What follows is what failed in each attack, where the "AI botnet" label goes wrong, and what zero trust changes for scripts, devices, developer tools and cloud accounts. It ends in India, where Gartner expects IT spending to grow 10.6% in 2027.
What do the x.cpe and Optimizely attacks have in common?
Both turned a trusted supplier into the attacker's delivery route, and both worked because trust was granted once, by origin, and never checked again.
In the Optimizely case, the malicious code arrived inside each customer's own snippet, from cdn.optimizely.com, over Optimizely's certificate. "Optimizely's CDN served exactly what it was given," wrote Report URI, the script-monitoring firm that found the code in 188 of the 1,611 Optimizely snippets it checked. A security policy that allows Optimizely's host could not tell the difference.
In the x.cpe case, the code arrived inside the device. According to Google's Threat Intelligence Group, Videostrong used obfuscation to exploit a gap in Google's compatibility and security tests and loaded the malicious code after the device's first boot. To the network around it, the box was just another device on the Wi-Fi.
NIST's zero trust architecture guide, SP 800-207, names both errors in its tenets: "Network location alone does not imply trust" and "No asset is inherently trusted". Neither an allowlisted CDN nor a certification badge is an exception.
How did the Optimizely attacker get in?
Through a flaw in the Web Experimentation signup flow that let newly created accounts act as existing administrators, using public account and project IDs plus guessed employee email addresses, according to Optimizely's interim report.
Optimizely shared the initial incident report with customers on 17 November. It gives this preliminary timeline, in UTC, for 16 November:
00:37: the attacker creates the first impersonating account, from IP addresses that include commercial VPN (ExpressVPN) addresses.
07:51: the first malicious code is written to a customer project.
13:34: Optimizely detects the activity.
16:06: it blocks the malicious code at Cloudflare.
16:10: the signup flaw is closed.
16:53: the impersonated users' sessions end and their tokens are revoked.
22:24: the injected code is gone from all affected projects.
The account and project IDs the attacker needed sit in every customer's public snippet. Optimizely calls them "references", not secrets. The rest came from guessing: variations on employees' names, repeated "for each impacted customer up to thousands of times".
Three answers in the report's customer questions matter more than the timeline. The impersonation "bypassed authentication", so companies whose staff sign in through single sign-on were hit too. The same route got past the protections on Optimizely's high-security PCI script host, cdn-pci.optimizely.com. And asked whether Project JavaScript can require approval before publishing, Optimizely replies that it has this "in as a feature request".
Read against NIST's tenets, the failure is plain. Tenet six says authentication and authorization are "dynamic and strictly enforced before access is allowed". Here, an unverified claim to be someone else was enough. Tenet four asks for policy that weighs behaviour, and thousands of guesses at one customer's staff emails is behaviour.
Optimizely says customers don't need to reset passwords or regenerate API tokens, because none were used. That is consistent: rotating credentials can't stop a flaw that needs none. What helps is limiting what any one identity can change, and raising an alarm when it changes something. Our report on the Optimizely supply chain attack covers what the payload did to visitors and how to check an Optimizely project.
Where does Optimizely's account differ from the researchers'?
On the start time, the attacker's domains and the protection a CSP gave: Optimizely puts the first malicious write at 07:51 UTC, but Report URI saw an injected BBC snippet at 04:21.
Report URI's timeline has the BBC's snippet loading code from webshell.lol at 04:21 UTC, two hours after the last clean copy anyone captured. Beazley Security found the same campaign in scripts from three other providers, Kissmetrics, StorifyMe and minute-ly, from 13 November. Optimizely was one of at least four script suppliers poisoned that week.
The indicators don't match either. Optimizely's report names pay-cloud[.]online, pay.pay-cloud[.]online and an exfiltration relay at pay-relay.wordpressadmin001.workers[.]dev. Every outside write-up we read names 1688360.cc, webshell.lol and a set of .icu domains instead. Optimizely calls its list preliminary and says the final report, after an investigation by Mandiant, will confirm the root cause and indicators. Until then, block and search your logs for both sets.
Then there is the claim about Content Security Policy (CSP), the header that tells a browser which hosts a page may load scripts from and send data to. Optimizely says "Sites with a strong Content Security Policy (CSP) were protected", because the skimmer loaded from an outside domain. But one version of the loader carried the whole payload inline and ran it through eval(). Report URI says that is how it ran at HSBC, whose policy blocked the outside domain. A policy is strong here only if it also refuses 'unsafe-eval' and 'unsafe-inline'.
Why couldn't owners remove x.cpe from their TV boxes?
Because x.cpe sits in the firmware's system partition with system-level privileges, reinstalls itself from the /oem/ partition after a reboot if deleted, and switches off Google Play Protect's app checks before installing anything.
Google's report describes a three-stage design. The x.cpe package, called com.oemservice in some builds, talks to its operators over MQTT, a lightweight messaging protocol, on the unusual ports 3885 to 3887. A loader called com.abc.nexus ran the paid modules. Since August 2026, droppers disguised as system apps, with names such as com.android.system.ntp, have been taking over from that loader.
The modules were the business. Most turned boxes into residential proxy exit nodes, which let paying customers route traffic through someone's home connection: Linkfog, AppSalt, NetNut's Popanet, Traffmonetizer and EarnFM's Fleet SDK among them, with up to three proxy SDKs on one box. Others committed ad fraud or loaded more backdoors. Google also saw Videostrong's operators take live screenshots, inject keystrokes, pull account data and open reverse shells.
Google's notes on one module show how quietly this ran. The AppSalt SDK, owned by Honeygain and in turn by Oxylabs, was switched on with an optIn() call that showed the owner no consent screen, and it stops running if the app came from Google Play. "Silent opt-in without user consent remains the most prevalent means by which devices are turned into exit nodes," Google wrote.
Taking down the servers did not clean the boxes. When we looked up the botnet's command domains, szbboys.com and anyevonline.com, in the .com registry's RDAP records on 19 November, both had been on "client hold" since 30 October, which keeps them out of DNS. The backdoor stays in the firmware of the boxes already sold, and Google warns that operators "quickly pivot to new loaders or rival monetization SDKs" when one part is disrupted. Our earlier report on the x.cpe backdoor after Google's takedown explains why a factory reset doesn't prove a box is clean.
Were x.cpe and the Optimizely attack AI botnets?
Neither attack used AI, as far as anything Google, Optimizely or the researchers have published shows: x.cpe was a manufacturer's backdoor rented to affiliates, and the Optimizely injection exploited a signup flaw.
The label still points at something real, just not these two cases. Google's AI Threat Tracker, published on 16 November, says attackers now run open-source multi-agent frameworks such as ARTEX, CAIRN, CyberStrikeAI and PentAGI in live intrusions; our ARTEX coverage traced that tool's attacks on banks. Google also found an exposed server running exploit_agent, a framework that compares code before and after a patch, drafts an exploit and runs it "without human intervention". Its operator went after French media and education websites.
Speed is the main change. Google counted zero-day exploits rising from a 2025 average of 8 a month to 11 a month in 2026, then 22 in August alone. Two PaperCut flaws, CVE-2026-81578 and CVE-2026-82078, were exploited across hundreds of organisations four days after disclosure, in a campaign GreyNoise believes used LLMs to build and test the exploits.
Botnets enter the story as infrastructure for AI abuse. In one Mandiant case, credentials that had probably been leaked or sold were used by "a set of IP addresses using a common User-Agent, likely a botnet or proxy service", which made millions of LLM API calls in about 24 hours before the credentials were revoked. Google says this "LLMJacking" has run up single-day fraudulent charges above $100,000. Anthropic's September threat report describes bots that used residential proxies and antidetect browsers to push through signup flows, and fake resellers of cheap Claude access that harvested buyers' credentials.
That is where x.cpe and AI meet. Residential proxies make automated traffic look like a household. Infoblox, which sees DNS traffic for its enterprise customers, counted monthly queries to residential proxy domains rising from nearly 400 billion to over 500 billion between January 2025 and April 2026. It says the most-seen proxy service "is associated with scraping for AI models". Nobody has shown whose traffic crossed the x.cpe boxes, but the market they were rented into serves AI scrapers, credential stuffers and fraudsters alike.
Google draws the conclusion defenders need: "the mechanics of the intrusions remain the same, such as using compromised credentials and targeting unpatched systems". AI changes how fast those old weaknesses are found. Zero trust is about not having them, or limiting what any one of them can reach.
What does zero trust actually require?
It requires that no user, device, script or network location is trusted by default, and that every request is authenticated, authorised and checked against current signals before it gets the least access it needs.
NIST calls zero trust "an evolving set of cybersecurity paradigms that move defenses from static, network-based perimeters to focus on users, assets, and resources". It is a set of principles, not a product you buy. Its seven tenets map onto the two attacks like this:
All data sources and computing services count as resources, including a TV box on the guest Wi-Fi and a vendor's script.
All communication is secured wherever it comes from, because being on the network proves nothing.
Access is granted per session, so a sign-in yesterday is not a standing pass today.
Access follows dynamic policy, so thousands of guesses at staff email addresses should change the answer.
The organisation monitors the integrity of every asset it owns or relies on, from firmware to third-party code.
Authentication and authorization are enforced before access, with no side door like Optimizely's signup flaw.
The organisation collects data on its assets and traffic and uses it to improve, from CSP violation reports to DNS logs.
The next three sections apply those tenets where these attacks went through: third-party scripts, devices on the network, and the identities behind developer tools.
Did the 178 organisations hit by OPTIMJACK tighten their CSP?
Not enough to stop a repeat: on 19 November, none of the 215 home pages we could fetch from the 178 organisations would have blocked all three versions of the attacker's loader.
We took the organisations and the 253 web hosts listed for them from Report URI's write-up and requested each home page once, from India, between 11:09 and 11:10 UTC. For every policy we replayed the attack's steps: load track.js from a new host, run the inline copy through eval() or as an inline script, then send data to the attacker. The tool, cspreplay, and the raw results are in our GitHub repository. These are the results for the 215 pages that answered:
90 pages, 42%, enforced no CSP at all, among them zoom.com and bbc.com, and 16 of those sent one in report-only mode.
53 pages refused a script from a host they had never listed, which stops the plain loader most infected snippets carried.
Every one of those 53 still allowed 'unsafe-eval' or 'unsafe-inline', the opening the inline copy needed, and 47 allowed both.
69 of the 125 pages that enforced a policy allowed 'unsafe-eval', while only 8 used 'strict-dynamic'.
36 pages had CSP violation reports switched on, and none required Trusted Types.
85 pages, from 57 organisations, still reference an Optimizely snippet in their HTML.
Counted the zero trust way, where an organisation is only as safe as its weakest host, 62 of the 156 organisations we reached had at least one host with no CSP. Another 43 refused new script hosts on every host we fetched. Report URI's count on 16 November, by its own method, was 68 with no CSP and 24 that blocked the payload, out of 159. The methods differ, so the two days don't compare exactly. The pattern does: the allowlists mostly work, and the exceptions undo them.
The only Indian site on the list, crocs.in, does send a policy, but its script-src allows any https: address, so it would have stopped nothing. The check has limits, too. We fetched home pages, not checkout pages, which may carry stricter policies, and 38 hosts that refused our requests, geo-blocked them, failed or timed out are missing.
How do you apply zero trust to third-party scripts?
Treat every third-party script as code someone else can change at any time: keep it off payment and login pages, list exactly which hosts it may load from and send to, and drop the eval and inline exceptions.
Optimizely's own report recommends the first step. Remove the Web Experimentation snippet from any page that takes payments or crypto transfers and runs no experiments. Card fields inside a payment provider's frame, such as Stripe's or Adyen's, were out of the skimmer's reach.
For pages that keep the snippet, this policy keeps the hosts Optimizely documents for visitors' browsers, minus 'strict-dynamic' and the frame used for cross-domain targeting. It is split over lines for reading; send it as one header line, with a fresh random nonce for each response:
Content-Security-Policy: default-src 'self';
script-src 'self' 'nonce-R4nd0m' https://*.optimizely.com
https://optimizely.s3.amazonaws.com https://cdn-assets-prod.s3.amazonaws.com;
connect-src 'self' https://logx.optimizely.com https://*.optimizely.com;
img-src 'self' https://cdn.optimizely.com;
style-src 'self' 'unsafe-inline' https://*.optimizely.com;
frame-src 'none'; report-uri /csp-reports; report-to cspcspreplay reports the loader, both inline paths, the data theft and the iOS exploit frame all blocked. The cost is real: features that evaluate strings, such as the audiences with custom JavaScript conditions in Optimizely's older guide, won't run, and every new third-party host has to be added by hand. Send it as Content-Security-Policy-Report-Only first, with a Reporting-Endpoints header for the csp name, and read what it would have blocked.
Compare a policy shaped like many bank sites' in our check. It lists its script hosts but keeps both exceptions:
$ python3 cspreplay.py policy --short "default-src 'self'; script-src 'self' 'unsafe-eval' 'unsafe-inline' https://cdn.optimizely.com; connect-src 'self' https://logx.optimizely.com"
[payload] blocked Load https://1688360.cc/track.js
[payload] allowed Run the inline copy through eval()
[payload] allowed Run the inline copy as an inline script
[theft ] blocked Send data to https://1688360.cc/card.php
[theft ] blocked Send data to https://1688360.cc/hit.php
Verdict: Payload ran, but connect-src blocked the data theftThat matches what Report URI saw at HSBC on 16 November, and all 12 HSBC sites we fetched had the same outcome three days later. The wallet-swapping part of the payload works inside the page, so it would still run.
Optimizely edited its CSP guide on 17 November, the day after the attack. A note that some features need 'unsafe-eval', there since at least 2023, is gone. Its example policies still use 'strict-dynamic', which trusts any script that a trusted script adds, from anywhere. On a site that copied the example, that setting would have let the loader through, so keep it out of policies for pages that run vendor-editable code.
Then lock down the vendor's console, because that is where this attack happened. Single sign-on with MFA would not have stopped a flaw that bypassed authentication, but it shuts out ordinary account takeovers. Give Project JavaScript edit rights to as few people as possible, and alert on every change. Optimizely says its application logs record which projects were targeted and what JavaScript changed, and customers can request those records.
How do you keep boxes like x.cpe's away from work systems?
Give them a network of their own with no route to work systems, let them reach only what they need on the internet, and never treat a device as trusted because it shares your Wi-Fi.
For a home office, that can be a router's guest network for the TV, the smart speaker and anything else nobody manages. For an office, it means a separate VLAN for TVs, signage and similar devices, with firewall rules that stop them from reaching internal subnets. Google found x.cpe on telehealth devices, karaoke machines and digital signage as well as set-top boxes.
Outbound rules matter as much. x.cpe's command channel used MQTT on ports 3885 to 3887, and its bootstrap servers lived under anyevonline.com and szbboys.com. A device network that may only reach DNS, NTP and the services each device needs would have cut that channel whatever the domain. Add both domains to your DNS blocklist anyway, so any box that still asks for them shows up in your logs.
Remote work needs the same rule. A VPN that drops a laptop onto the company network trusts the laptop's whole home network along with it. Zero trust network access checks the user and the device's state for each app and each session, so a TV box next to the laptop gets nothing.
Residential proxies also break a common login defence. TrendAI, one of the takedown partners, said in the partners' joint announcement that attacks run through these proxies "would commonly include identity theft impersonating people in their region". If the attacker's traffic comes from a home connection in your customer's own city, IP reputation and geo-blocking say little about who is asking. Per-account rate limits, passkeys and device binding say much more. The Optimizely attacker's thousands of guesses per customer show what per-account limits are for.
How do you apply zero trust to developer tools and cloud accounts?
Give every pipeline, agent and API key a short-lived, narrowly scoped identity, protect the files that tell tools what to run, and alert on use that doesn't fit the owner.
Long-lived cloud keys stored as CI secrets are easy to steal and hard to notice. GitHub Actions, GitLab CI and most other runners can instead trade a short-lived OpenID Connect token for cloud credentials limited to one repository and branch, so no stored key exists to leak. Our guide to auditing API keys after the Northflank breach shows how to find the long-lived ones you already have.
Treat AI keys the same way. Anthropic's report says organisations "should treat AI keys and agent integrations with the same level of seriousness as they do production credentials". Use a separate key per application, with a spending limit and alerts, because Mandiant's LLMJacking cases ran up six-figure bills in a day. Patch AI gateways too: Google saw attackers use CVE-2026-40217 in the LiteLLM proxy to turn limited "virtual keys" into full administrative credentials.
Agent configuration needs the same protection as code. In 2026 intrusions at cryptocurrency firms, Google says a suspected North Korean cluster it tracks as MIDNIGHT NEPTUNE changed .claude/settings.json files in victims' internal repositories, so Claude Code downloaded the SOMBERMEME backdoor when developers started it. Put .claude/, .mcp.json and CI workflow files under CODEOWNERS with required review. Our MCP security guide covers the Claude Code settings that limit what a repository can switch on.
Finally, apply the Optimizely lesson to every SaaS console your team uses, from analytics to feature flags. Ask for single sign-on with MFA, keep the list of editors short, send audit logs somewhere someone reads them, and alert when anyone changes code that ships to customers.
What does India's 10.6% IT spending growth mean for security?
It means a lot of new trust decisions arriving at once: Gartner expects Indian IT spending to reach ₹16.9 trillion in 2027, with spending on cloud infrastructure (IaaS) up 40.3% and on data centre systems up 28.4%.
In the forecast, released on 17 November, Gartner's DD Mishra says "AI infrastructure and digital sovereignty are becoming strategic priorities". That is narrower than saying the growth is driven by digital sovereignty. Gartner's release names sovereign capabilities as one driver among several, alongside global capability centres, AI-optimised infrastructure and cloud, cybersecurity and data modernisation.
Sovereignty and zero trust answer different questions. Keeping data and compute in India decides where data lives and whose law applies. It doesn't stop a vendor's script from skimming an Indian customer's card, or a proxy exit node in that customer's city from signing in as them.
CERT-In has already put zero trust in writing. Its Blueprint for Reducing Exposure and Defending against AI-Assisted Vulnerabilities Exploitation, version 1.0 of 25 May 2026, lists "Zero Trust Security" among its core principles: "Enforce continuous verification and least-privilege access", through MFA, privileged access management, micro-segmentation, conditional access and session monitoring. It also asks for supply-chain checks: vendor assessments, SBOMs and provenance validation.
The blueprint's deadlines are written for AI-assisted attackers. For a known exploited flaw in internet-facing critical systems, it expects immediate containment and a patch, mitigation or removal of the exposure within 12 hours where feasible. Critical externally exposed flaws get one day. A June guideline for OEMs and technology providers serving Indian organisations asks them to tell affected customers and CERT-In "immediately" about critical and high-severity flaws, with interim mitigations, and to share indicators of compromise for zero-days.
Both documents are guidance: they say "should" and "advised". The binding rule is older. CERT-In's directions of 28 April 2022 require organisations to report listed incidents, including attacks on e-commerce applications and data breaches, within 6 hours of noticing them. They also require ICT system logs kept for a rolling 180 days within Indian jurisdiction. A skimmer found on your checkout page on a Monday afternoon is a report due that evening.
What should you do this week?
Start with the changes that close the doors these two attacks used, then work outwards:
Block and search your logs for both sets of Optimizely indicators: 1688360.cc, webshell.lol and the .icu domains, plus pay-cloud[.]online and its workers.dev relay.
Remove experimentation and tag snippets from checkout, login and crypto-transfer pages that run no tests.
Check your policy with cspreplay, then drop 'unsafe-eval', 'unsafe-inline' and 'strict-dynamic' wherever vendor-editable code runs.
Turn on CSP reporting, so a new script host shows up as a report instead of a breach.
Put TVs, signage and other unmanaged devices on their own network, with outbound traffic limited to what they need.
Replace stored cloud keys in CI with short-lived OIDC credentials, and give every AI key its own spending limit.
Add .claude/, .mcp.json and CI workflow files to CODEOWNERS with required review.
Decide who reports to CERT-In within 6 hours, and check that your logs go back 180 days.

Neither attack needed a stolen password or a zero-day in the victims' own code. Both needed something that was trusted once and never asked again, and that is the habit zero trust replaces.
Frequently asked questions
Is zero trust network access (ZTNA) the same thing as zero trust?
Not quite. ZTNA tools replace VPN-style network access with per-application access that checks the user and the device on each session, which covers part of what NIST describes. Zero trust also covers how you treat vendors' code, devices nobody manages, API keys and data, and no single product handles all of that.
How can I check an Android TV box for x.cpe myself?
If you can connect with adb, run adb shell pm list packages and look for the names in Google's report: x.cpe, com.oemservice, com.abc.nexus, com.android.system.ntp and com.android.sso.auth.handler. Then run adb shell settings get global package_verifier_user_consent: x.cpe sets it to -1 to switch off Play Protect's checks, though the same value can mean someone declined verification by hand. A match is a reason to disconnect the box, not a full diagnosis.
Does Subresource Integrity (SRI) stop attacks like the Optimizely one?
Not for a file like an Optimizely snippet, which changes every time someone publishes an experiment: a fixed hash would break the snippet at the next legitimate change. SRI suits files that never change, such as a pinned library version. For live vendor files, rely on CSP limits and change monitoring.
Is 'strict-dynamic' ever a good idea?
Yes, for code you control. With a nonce, it stops an attacker who injects a script tag into your HTML, because they can't know the nonce, and it saves you maintaining long host lists for loaders. The risk comes when someone else can change a trusted script, such as a vendor snippet edited in the vendor's console: everything that script inserts is then trusted too.
Sources
- PaperSecurity Incident Initial Report for Customers: Optimizely Web Experimentation (Optimizely, 17 Nov 2026) · pages.optimizely.com
- Write-upWorld's Largest Brands Infected With Malware Via Optimizely (Report URI) · blog.report-uri.com
- Write-upShutting the Door on the XCPE Botnet (Google Threat Intelligence Group) · cloud.google.com
- Write-upGTIG AI Threat Tracker: Agentic Threat Activity Crosses a Significant Threshold (Google, 16 Nov 2026) · cloud.google.com
