Skip to content
NewCybercrime Report 2026 · Eight Chapters · A Post Is Not An Incident → Explore The ChaptersCybercrime Report 2026 → Explore
All full reports
Full reportEnterprise exploitationMonograph 30 / 1919 min read

Stolen Cloud Keys, Backdoored WordPress: Inside the pax_cmd Chain

How a stolen Google Cloud service-account key becomes a WordPress backdoor, and what the operator's workspace shows

By
Odin by Brandefense
Published
19 November 2026
Reading time
19 min read
Edition
Version 1.1 · TLP:CLEAR
Scope
Prepared November 2026

1. Executive Summary

In short

In a two-week observation window ending 18 November 2026, Odin by Brandefense recovered a two-version Python playbook from an exposed attack archive. It uses a stolen Google Cloud service-account key to overwrite WordPress theme files inside a storage bucket that feeds a live web root. A hidden pax_cmd parameter is then meant to turn every page into a command gate. Twin Behinder webshells show the same fix-and-retry habit. Restrict bucket writes to deployment accounts, remove workstation service-account keys, and block pax_cmd requests at the WAF.

Many WordPress platforms now keep theme and media files in cloud object storage and sync them into the web root. That design is convenient, but it moves the line between cloud identity and server code. This report shows how one operator exploits that line, using 29 code files left on nine open web directories.

1

Bucket write access turns a stolen service-account key into WordPress code execution.

Two Python scripts from an exposed ARTEX archive, tied to the archive's iGaming task (1,231 recorded worker runs), mint a Google OAuth token from a stolen key. They are written to overwrite a theme's 404.php and functions.php inside an iGaming staging bucket. The second version fixes a key-parsing bug in the first.

2

Twin Behinder webshells show the same repair cycle for PHP 8.

On a separate open directory, two small PHP webshells use AES-128 with a 16-byte XOR fallback and Behinder v3's public default key. The first version breaks on PHP 8.0. The second swaps in buffered eval to run on PHP 8.

3

The same archive holds unverified claims against a crypto exchange.

The archive's crypto-exchange task records 2,178 worker runs against a Southeast Asian exchange. Its logs claim SQL injection into a linked database server, a webshell on a backup NAS and a harvested cloud key. None of these claims is confirmed.

Three Decisions for Leaders

  1. Treat buckets that feed web roots as production code. Only CI/CD accounts should write to theme folders. Alert on any PHP object written to such a bucket, and baseline the deployed theme files.
  2. Remove long-lived service-account keys from workstations. Move developers to short-lived federated tokens, strip project-editor rights, and block new key creation by policy.
  3. Layer web, cloud-audit and PHP runtime controls. Block pax_cmd requests, alert when PHP workers start shells, and patch PHP to 8.2.35, 8.3.36, 8.4.27 or 8.5.12.

The Study in Numbers

NumberWhat it is
29Code files on nine open web directories (21 unique SHA-256 digests)
2Versions of the Python bucket-to-WordPress playbook (5,251 and 5,480 bytes)
2Behinder-compatible PHP webshells, one for PHP 7 and one rebuilt for PHP 8
15Third-party package files among the 29, which yield 13 strings that look like domains but are not
1,231Worker runs the archive records for its iGaming task, the one behind the playbook
2,178Worker runs the archive records for its crypto-exchange task
731Nodes (795 edges) in our analytical model of the wider operator infrastructure

How to use this report.

Security leaders can read Chapters 1, 6 and 7. Cloud, DevOps and CMS teams should read Chapters 3 and 7. SOC and detection engineers should start with Chapters 8 and 9. CTI analysts will find the workspace and infrastructure detail in Chapters 2, 4 and 5.

2. What Was Found: 29 Files on Nine Hosts

In short

Nine open web directories held 29 code files. Only four are offensive scripts; fifteen are ordinary package files that would flood a watchlist with false domains if taken at face value.

Sandbox runs of compiled malware show how an implant calls home. They rarely show how an operator logs in to a cloud API or fixes a broken script. Code left in an open web directory can show both. We read the files as text. We did not run any of them, and we did not contact any system named in them.

Open directories mix custom attack scripts with whole Python virtual environments and developer agent folders. Reading every string as an indicator produces noise. So the first step is to sort the files by what they are.

Figure 1: Shared artifacts link autonomous task archives to open directories
Figure 1: Shared artifacts link autonomous task archives to open directories

Five kinds of file

The 29 files are 24 Python scripts, 2 PHP files, 2 JavaScript files and 1 shell script. They hash to 21 unique SHA-256 digests. Seven duplicates come from Linux virtual environments that link /venv/lib to /venv/lib64. One more is a second copy of calibrate.py.

ClassFilesUnique SHA-256HostsSize range (bytes)What it is
Offense playbook2215,251 to 5,480Bucket-to-WordPress pax_cmd deployers for the iGaming task
Webshell pair221569 to 755Behinder-compatible AES-128/XOR PHP 7 and PHP 8 webshells
Operator utilities4321,421 to 28,367A CVE-2026-109618 calibration script, a key generator and a rule generator
Agent and bot code6633,933 to 28,633AI coding-agent folders and chat-bot scripts
Package files15832,976 to 43,572telnetlib3, numpy, pip and a mini-program UI component
Figure 2: Static review separates four offense scripts from fifteen package files
Figure 2: Static review separates four offense scripts from fifteen package files

Package files are noise, not indicators

More than half of the files (15 of 29, 51.7%) are third-party packages. A naive domain pattern pulls 13 strings out of them: docstring words and attribute names that happen to look like domains, such as Python's logger[.]info call. None of them is attacker infrastructure. Keep package paths out of indicator extraction before anything reaches a SOC watchlist.

Every network address inside the 29 files was already known from Odin's research into 4,360 autonomous-offense endpoints on 2,917 hosts (Monograph 11). The files added no new command-and-control addresses.

Owners are not always operators

The nine hosts play different roles. Three of them expose AI coding-agent folders, bot scripts or a telnetlib3 virtual environment. Nothing on those three shows offensive tooling, so we treat their owners as users, not operators. All nine host addresses are withheld.

Host roleFilesUnique SHA-256Main contents
Python package host105Python 3.13 telnetlib3 files in lib and lib64
Bot host64Two Python bot modules with numpy and pip
AI agent host33Hermes agent folders and an Orca terminal shell hook
Archive host22deploy_gcs_webshell.py and deploy_gcs_webshell2.py
Webshell host22/serve/shell.php and /serve/shell2.php
Utility host22A key-generation script and a rule-generation script
CVE calibration host21/CVE-2026-109618/tools/calibrate.py (two copies)
UI component host11One mini-program JavaScript component
Chat-bot host11One QQ chat-bot script

3. The pax_cmd Playbook: From Service-Account Key to Theme Backdoor

In short

When a cloud bucket feeds a WordPress web root, the right to write to the bucket is the right to change the site's code. The two deployer scripts are built around that fact and need no login to the web server itself.

Modern WordPress hosting often runs stateless PHP containers. Themes and media live in cloud object storage, which is synced or mounted into wp-content/. Teams tend to treat the bucket as passive storage. Once executable .php theme files live there, cloud IAM controls who can change server code.

The two scripts sit in the exposed ARTEX archive, next to the records of its iGaming task. Read side by side, they show the operator fixing a crypto bug and then widening the backdoor to every page.

Figure 3: Bucket write privilege turns a service account into a CMS backdoor
Figure 3: Bucket write privilege turns a service account into a CMS backdoor

Version 1 breaks the key, version 2 fixes it

Both scripts read a stolen Google Cloud service-account key from the task path i21899/gcs_service_account.json. A service-account key is a JSON file that holds an RSA private key in PEM format.

Version 1 (deploy_gcs_webshell.py) strips every newline from the JSON text before parsing it. PEM keys need those line breaks around the BEGIN and END markers. Without them the key is corrupt, and RS256 JWT signing fails on the operator's machine.

Version 2 (deploy_gcs_webshell2.py) drops that shortcut. It pulls private_key, client_email and private_key_id out with re.DOTALL regular expressions, which keep the line breaks intact. With a valid key it builds a signed JWT assertion with a 3,600-second lifetime.

The assertion asks for two broad OAuth 2.0 scopes: devstorage.full_control and cloud-platform. The script posts it to oauth2.googleapis[.]com/token with grant type urn:ietf:params:oauth:grant-type:jwt-bearer. Google returns a one-hour bearer token. This is the standard server-to-server flow, used here with a stolen key (T1528, T1078.004).

Listing the bucket and writing the theme

With the token, both versions call the Cloud Storage JSON API at storage.googleapis[.]com. They list up to 500 objects in the victim's bucket. The loop looks for object names containing .php, wp-config, 404 and .env. Those names confirm that the bucket holds the live WordPress tree of an iGaming staging site.

The scripts then upload two files with POST /upload/storage/v1/b/<bucket>/o?uploadType=media and the header Content-Type: application/x-php. Both files go into the active theme's folder under wp-content/themes/. The bucket name, the theme name and the staging site are withheld because they identify the victim.

File writtenWhat it does
Theme 404.phpReplaces the theme's missing-page handler. Any unrouted request now checks for a pax_cmd value in $_REQUEST. A value is passed to system, then passthru, exec or shell_exec if the first is disabled.
Theme functions.phpWordPress loads the active theme's functions.php on every front-end and admin request. Version 2 ships this file Base64-encoded and keeps a stub of the original, so the theme still renders.

The gate has no IP restriction and no secret check. Anyone who finds the parameter can use it (T1505.003).

The verification probes

After the upload, each script is written to test the gate with curl -sk and the harmless command id. Version 1 tries three paths. Version 2 drops two of them and adds a root query, which relies on the functions.php hook.

AttributeVersion 1 (deploy_gcs_webshell.py)Version 2 (deploy_gcs_webshell2.py)
Size and length5,251 bytes, 137 lines5,480 bytes, 126 lines
Key inputi21899/gcs_service_account.jsoni21899/gcs_service_account.json
PEM parsingStrips newlines, breaks RS256re.DOTALL, keeps newlines
Token requestjwt-bearer, 3,600 s, storage and cloud scopesSame
Objects uploadedTheme 404.php and functions.phpTheme 404.php and Base64 functions.php
Probe pathsTheme 404.php?pax_cmd=id, /wp-content/404.php?pax_cmd=id, /pax_cmd.php?pax_cmd=idTheme 404.php?pax_cmd=id, /?pax_cmd=id

These are scripts, not logs of a result. Nothing we saw shows whether the upload or the probe worked against the staging site.

4. Behinder Twins and Workspace Utilities

In short

The fix-and-retry habit also shows up in PHP webshells. A PHP 7 webshell that breaks on PHP 8 sits next to a rebuilt PHP 8 version, both keyed with Behinder's public default.

Two webshells, one repair

A separate open directory holds /serve/shell.php (569 bytes, 25 lines) and /serve/shell2.php (755 bytes, 35 lines). Both speak the Behinder v3 protocol. Behinder is a public Chinese webshell manager that encrypts its traffic.

Each file reads an HTTP POST body, Base64-decodes it and decrypts it with OpenSSL AES128. If the OpenSSL extension is missing, it falls back to a 16-byte rolling XOR. Both derive their 16-byte key from Behinder v3's public default: the first 16 hex characters of MD5('rebeyond').

The difference is how they run the decrypted code. Version 1 passes it to create_function, which PHP deprecated in 7.2 and removed in 8.0. On a modern stack it fails with a fatal error. Version 2 replaces it with ob_start and eval, and encrypts the response the same way.

FileSizeLinesHow it runs codePHP versions
/serve/shell.php569 bytes25create_functionPHP 7 only
/serve/shell2.php755 bytes35ob_start and eval, encrypted outputPHP 8.x

Because both keep the public default key, Behinder traffic signatures and the file hashes in Chapter 9 both apply.

A PHP crash-bug calibration script

Another host holds two copies of /CVE-2026-109618/tools/calibrate.py (3,417 bytes each). CVE-2026-109618 is a critical PHP flaw. PHP mishandles uninitialized memory while cleaning up after an out-of-memory error, which allows remote code execution. The PHP project fixed it on 21 October 2026 in 8.2.35, 8.3.36, 8.4.27 and 8.5.12. PHP 8.1 and 7.x are end-of-life and get no fix.

A calibration script of this kind tunes memory layout before an exploit attempt, so it points at web-facing PHP targets. The script's owner is not established, so its hash is withheld.

Utilities and agent folders

A fourth host holds a key-generation script (1,421 bytes) and a rule-generation script (28,367 bytes). Three more hosts expose Hermes agent folders, an Orca terminal shell hook, a QQ chat-bot script and two Python bot modules. These may belong to independent developers running AI coding agents on badly configured servers. We keep them on a watchlist and withhold their hashes and addresses.

5. Archived Crypto-Exchange Claims and the Operator Model

In short

The archive that held the playbook also holds swarm logs for 76 anonymized scopes. Read them as a threat model for database, NAS and cloud IAM segmentation, not as proof of a breach.

Autonomous red-team frameworks such as ARTEX save worker transcripts, bucket listings and LLM-written test reports to disk. When an operator leaves that workspace on open HTTP, defenders can read how a swarm chains reconnaissance into cloud and database pivots.

Figure 4: Iterative script repairs recur across cloud and webshell workspaces
Figure 4: Iterative script repairs recur across cloud and webshell workspaces

What the crypto-exchange task claims

The crypto-exchange task records 2,178 worker runs against a Southeast Asian cryptocurrency exchange. No names, hostnames or bucket identifiers are disclosed. LLM-driven attack tools often overstate impact or log commands that never ran. So every item below is an unverified claim from the attacker's own records.

Claim in the archiveWhat it says
Linked-server SQL injectionA web or API SQL injection path was used to enable xp_cmdshell on a linked Microsoft SQL Server holding a production exchange database
NAS backup webshellAn unauthenticated PHP webshell was placed on a NAS backup mount reachable from the database network
Workstation cloud keyA Google Cloud project-editor service-account key was taken from an internal workstation, with further attempts to mint keys for a pentest account and reach Identity-Aware Proxy (IAP) dashboards
Cached access and bucket listsCached VPN certificates, SSH key pairs and two exchange bucket names; sibling tasks list banking and fintech buckets

All bucket names in these records belong to targets and are withheld.

The operator model

We model the wider infrastructure as one collector-operator cluster. This is an analytical model, not a proven actor. It rests on concrete links: shared endpoint hashes, reused secrets and certificates, and exposed task queues.

The model has 731 nodes and 795 edges. Of those edges, 76 are strong links such as a shared hash, secret or certificate. Three habits support the single-operator reading.

  1. Template and key reuse. The two webshells reuse Behinder's public key. Elsewhere in the model, three hosts on Tencent cloud share a byte-identical shell.aspx and 16 secrets. A pair of controllers on LUCIDACLOUD hosting shares 714 endpoint hashes.
  2. Sector focus. The iGaming playbook fits four Russian-language casino and compliance Telegram bots and four Telegram control groups found in public sources.
  3. Chronic exposure. Leaving the playbook and the crypto-exchange logs in an open directory matches 634 exposed Python HTTP servers and 112 exposed AI agent-session hosts elsewhere in the model.
Model metricCountWhat it means
Nodes and edges731 / 795Includes 76 strong cross-host links
Documented access surfaces271Drop sites, bot and config credentials, templates, panels and databases
Exposed Python HTTP servers634The same open-directory pattern as the archive host
Shared endpoint hashes, LUCIDACLOUD pair714Dense overlap between two paired controllers
Shared secrets, Tencent trio16Alongside a byte-identical shell.aspx on three hosts
Exposed AI agent-session hosts112Hosts that leak agent transcripts or workspace folders
Telegram artifacts from public sources4 + 4Four casino and compliance bots and four control groups

6. Who the Swarm Targeted, and Other Explanations

In short

Payments, fintech and Web3 firms make up more than half of the 76 scopes in the archive. The swarm's own severity labels are unverified, and other readings of the archive remain possible.

Figure 5: Swarm scopes target fintech and Web3; package files add noise
Figure 5: Swarm scopes target fintech and Web3; package files add noise

The archive lists 76 anonymized target scopes and 13,864 enumerated subdomains. Of those, 1,105 were live HTTP or TLS hosts. All target names are withheld.

SectorScopesShareSubdomainsKey task or bucket evidence
Payments and Fintech2127.6%3,910Production and development buckets (names withheld)
Web3, DeFi and Stablecoin2026.3%3,420Multi-worker subdomain and API reconnaissance
Enterprise Tech and SaaS1114.5%2,180Cloud workbench and SaaS tenant enumeration
iGaming and Online Casino1013.2%1,890The iGaming task (1,231 runs) and the bucket playbook
Banking and Insurance810.5%1,410Banking and CDN buckets (names withheld)
Crypto Exchanges67.9%1,054The crypto-exchange task (2,178 runs) and backup bucket claims

Four ways to read the evidence

  1. Package noise. Raw string matching over site-packages and UI bundles produces false domains. The 15 package files are not indicators, and none of their 13 domain-like strings belong on a block list.
  2. An authorized test gone wrong. Task-numbered folders, structured penetration_test_report.md outputs and a pentest-named service account in the crypto-exchange task fit a contracted red team misconfiguring an ARTEX server. Even so, an unauthenticated pax_cmd gate in a live theme file exposes the site to anyone, and needs urgent remediation.
  3. Developers, not operators. Hosts with Hermes, Orca or bot folders may belong to developers running local AI agents. They stay on a watchlist, and their addresses are not published.
  4. Inflated LLM severity. The archive's LLM summaries rate 22.4% of scopes critical (3 claimed remote code execution, 14 claimed data or key exposure) and 23.7% high, 46.1% combined. Only the iGaming task comes with recovered deployment code.

7. What Defenders Should Do

Cloud and WebOps

  • List every Cloud Storage, S3 or R2 bucket synced or mounted into a web root (wp-content/themes/, wp-content/uploads/). Turn off PHP execution on media mounts and turn on DATA_WRITE audit logs for those buckets.
  • Allow theme-folder writes only from named CI/CD service accounts. Alert on any application/x-php object written by anyone else.

Cloud IAM

  • Revoke long-lived user-managed service-account keys on workstations. Enforce constraints/iam.disableServiceAccountKeyCreation.
  • Remove roles/editor from CI and developer accounts. Review OAuth jwt-bearer token requests from hosts outside Google Cloud.

CMS and platform

  • Record hashes of the deployed 404.php and functions.php for every theme, and alert on drift. Mount core and theme code read-only on origin containers.
  • Set disable_functions = system,passthru,exec,shell_exec in php.ini where the site allows it.
  • Upgrade every internet-facing and staging PHP runtime to 8.2.35, 8.3.36, 8.4.27 or 8.5.12 or later for CVE-2026-109618. Retire PHP 7.x, 8.0 and 8.1 pools.

Detection and network

  • Block pax_cmd in query strings and POST bodies at the WAF, and deploy the rules in Chapter 8 on staging and production tiers.
  • Check MSSQL linked servers for xp_cmdshell, and separate NAS backup mounts from database and web networks. These are the paths the crypto-exchange task claims.

8. Detection Rules

The full rules are in the Detection rules tab. Every rule file loads without errors in its engine (Suricata 7.0.12, YARA-X, pySigma, Kusto.Language); the rules were not replayed against live traffic. Test them in your own environment before production use.

Rule fileWhat it catches
odin_pax_cmd_gcs_wordpress_backdoor.rulesSuricata 7: eight signatures for pax_cmd gates, direct theme template requests, PHP uploads to Cloud Storage, jwt-bearer token requests, the deployer scripts, the twin webshells and exposed workspace listings
sentinel_gcs_theme_overwrite_and_pax_cmd_hunt.kqlMicrosoft Sentinel and Defender XDR: PHP workers starting shells, deployer command lines, and non-CI calls to Google OAuth and Storage APIs
sigma_gcs_sa_key_abuse_and_cms_webshell_deploy.ymlSigma (3 rules): PHP theme writes in Cloud Storage audit logs, PHP workers spawning shells, and deployer or probe command lines on Linux
odin_pax_cmd_deployer_and_behinder_twin_artifacts.yarYARA (4 rules): the deployer scripts, injected pax_cmd theme files, the Behinder twins and workspace files naming the stolen key or the CVE calibrator

How the Suricata signatures work

SIDLooks forWhy
9530001pax_cmd= in an inbound request URICatches use of the injected gate through a query string (block candidate)
9530002pax_cmd= in an inbound POST bodyCatches the same gate through a form body (block candidate)
9530003A direct request for any theme's 404.php or functions.phpNormal visitors never request these files by path
9530004Outbound POST /upload/storage/v1/b/ with uploadType=media, a wp-content path and Content-Type: application/x-phpCatches a PHP theme write to Cloud Storage (needs TLS inspection)
9530005Outbound POST to oauth2.googleapis[.]com with a jwt-bearer grant and an assertionHunt only: flags token requests from hosts where cloud SDKs should not run
9530006Outbound GET for deploy_gcs_webshell.py or deploy_gcs_webshell2.pyCatches retrieval of the playbook
9530007Inbound request for /serve/shell.php or /serve/shell2.phpCatches access to the twin webshell paths
9530008A directory listing that names the deployer, the key file or CVE-2026-109618Catches an exposed workspace of this kind on your own network

Use SIDs 9530001 and 9530002 in inline block mode once approved CMS proxies have pass rules. Keep SID 9530005 as a hunt signal on workstations and web tiers.

How the other rules work

The KQL query looks back 7 days. It joins two views of each device. The first finds a PHP or web worker (php-fpm, apache2, httpd, w3wp.exe and similar) starting id, whoami, uname, a shell, curl or wget. It also finds command lines naming the deployer, the key file, pax_cmd= or uploadType=media. The second finds Python, curl or PHP processes calling Google OAuth or Storage APIs.

Each match gets one of three labels: isolate a cloud key deployer, isolate a pax_cmd webshell, or hunt an unapproved API call. Exact runner hostnames go in two named allowlists. There are no wildcards.

The first Sigma rule reads Google Cloud audit logs. It flags storage.objects.create or update on PHP files under wp-content/themes/ or wp-content/plugins/, or on 404.php, functions.php, pax_cmd.php or the /serve/ webshell names. Two exact deployment service accounts are excluded. The second Sigma rule flags PHP or web workers that spawn shells or recon tools. The third flags Python or curl command lines that name the deployer, the key file, pax_cmd=id or the CVE calibrator.

YARA ruleFires when
ODIN_GCS_WordPress_PaxCmd_Deployer_PlaybookA Google OAuth token marker appears with devstorage.full_control, uploadType=media and either a theme path or pax_cmd
ODIN_WordPress_PaxCmd_Injected_Theme_Gatepax_cmd and _REQUEST appear with two of system, passthru and shell_exec
ODIN_Behinder_AES128_XOR_Twin_PHP_WebshellAES128, openssl_decrypt and the XOR index marker appear with create_function or ob_start
ODIN_GCS_SA_Workspace_and_Probe_ArtifactTwo of the key file name, the deployer name and application/x-php appear, or the CVE name appears with tools/calibrate.py

MITRE ATT&CK mapping

TacticTechniqueHow the chain uses itDetection
Defense Evasion, PersistenceT1078.004 Valid Accounts: Cloud AccountsA stolen service-account key signs in to Google CloudSID 9530005; KQL; Sigma rule 1
Credential AccessT1528 Steal Application Access TokenThe key is traded for a one-hour bearer token with full storage rightsSID 9530005; Sigma rule 3
PersistenceT1505.003 Server Software Component: Web Shellpax_cmd theme gate and the Behinder twin webshellsSIDs 9530001 to 9530004 and 9530007; Sigma rules 1 and 2; YARA

9. Indicators

The Indicators tab holds 4 published indicators: 4 file hashes (SHA-256) and no addresses. Eight more indicators appear in this report only: the pax_cmd parameter, three probe URIs, three cloud API patterns and the stolen key's task path.

TypeCountWhere to use it
Network addresses0All host addresses are withheld
File hashes (SHA-256)4EDR and file-integrity scanning
Web request parameter and probe URIs4WAF rules and web access logs
Cloud API patterns3Cloud audit logs and TLS egress proxies
Workspace file path1Endpoint command-line and file hunting

File hashes

FileSize (bytes)SHA-256Use
deploy_gcs_webshell.py (version 1)5,25120745360f904db566a373ce39bb05ea52fee24c5f6a404db756e9c5aecb1981eHunt on workstations and servers
deploy_gcs_webshell2.py (version 2)5,48017c96f2ab239b6fd5b5454aae51301bee2021f0b8d9726c567c48b8ab167fbdcHunt on workstations and servers
/serve/shell.php569d0c6e2776390e00684969931b003047b5f5b7c483e1cf263320d8181bbab94fcBlock in web roots
/serve/shell2.php75567e9658391a17bc1e8dd23250bd5b99d4ef5c2e0f63d08f3c3a8abe61925c8bcBlock in web roots

Other indicators

IndicatorTypeUse
pax_cmdQuery or POST parameterBlock at the WAF
/wp-content/404.php?pax_cmd=idProbe URI (version 1 fallback)Block at the WAF
/pax_cmd.php?pax_cmd=idProbe URI (version 1 root fallback)Block at the WAF
/?pax_cmd=idProbe URI (version 2 functions.php check)Block at the WAF
oauth2.googleapis[.]com/token with grant type jwt-bearerCloud API patternWatch, do not block the domain
devstorage.full_control scopeOAuth scopeWatch in IAM logs
storage.googleapis[.]com/upload/storage/v1/b/*/o?uploadType=mediaCloud API patternHunt for PHP writes
i21899/gcs_service_account.jsonWorkspace file pathHunt on endpoints

The Google domains are legitimate services. Never block them at the firewall. Look for unusual callers instead.

Withheld: all nine host addresses, every bucket name, the victim staging site, the theme name in the overwritten paths, and the hashes of the nine utility, agent and bot files whose owners are not established.

10. Scope and Limits

  • Window. The findings cover a two-week observation window ending 18 November 2026.
  • Code, not outcomes. The playbook and webshells were read as text. Nothing we saw confirms that the bucket upload, the theme overwrite or the pax_cmd probe worked on the staging site.
  • The archive speaks for the attacker. Worker counts, the crypto-exchange claims and severity labels come from the swarm's own logs and LLM reports. We confirmed none of them on a target system.
  • One operator is a model. The 731-node cluster is an analytical model built on shared hashes, secrets and certificates. It is not a named actor.
  • An authorized test is possible. Some archive features fit a contracted red team. The unauthenticated backdoor still puts the victim site at risk.
  • Users are not operators. Hosts with only agent, bot or package files are treated as users, and their files are not published as indicators.
  • Rule testing. Every published rule file loads without errors in its engine (Suricata 7.0.12, YARA-X, pySigma and Microsoft's Kusto.Language analyzer, checked on 20 November 2026). The rules were not replayed against live traffic, so test and tune them in your own environment before production use.

11. Sources

  1. Google Cloud. Best practices for managing service account keys. https://cloud.google.com/iam/docs/best-practices-for-managing-service-account-keys (verified 20 November 2026)
  2. Google Cloud Storage. JSON API v1, Objects: insert. https://cloud.google.com/storage/docs/json_api/v1/objects/insert (verified 20 November 2026)
  3. Google Identity. Using OAuth 2.0 for server to server applications. https://developers.google.com/identity/protocols/oauth2/service-account (verified 20 November 2026)
  4. WordPress Developer Resources. Theme Handbook: Template Hierarchy. https://developer.wordpress.org/themes/basics/template-hierarchy/ (verified 20 November 2026)
  5. MITRE ATT&CK. T1078.004 Valid Accounts: Cloud Accounts. https://attack.mitre.org/techniques/T1078/004/ (verified 20 November 2026)
  6. MITRE ATT&CK. T1505.003 Server Software Component: Web Shell. https://attack.mitre.org/techniques/T1505/003/ (verified 20 November 2026)
  7. MITRE ATT&CK. T1528 Steal Application Access Token. https://attack.mitre.org/techniques/T1528/ (verified 20 November 2026)
  8. OWASP Cheat Sheet Series. File Upload Cheat Sheet. https://cheatsheetseries.owasp.org/cheatsheets/File_Upload_Cheat_Sheet.html (verified 20 November 2026)

What is…?

Short explanations of the tools and families named in this study.

All explanations

Frequently asked questions

What did we find?

Nine open web directories held 29 code files. Only four are offensive scripts. Fifteen are ordinary Python and JavaScript package files, and the rest are utilities and developer agent folders.

How does the attack chain work?

Many WordPress platforms keep themes and media in cloud storage and sync them into the web root. The playbook is built around that design. The steps are: The two versions show an operator fixing a bug. Version 1 strips line breaks from the key file, which corrupts the private key and breaks signing. Version 2 fixes that with a better parser and hides the new functions.php in Base64.

Why do the webshells matter?

The two webshells show the same fix-and-retry habit. Both decrypt incoming commands with AES-128, or a 16-byte XOR fallback, using Behinder's public default key. The first version relies on a PHP function that was removed in PHP 8.0, so it fails on modern servers. The second version swaps in buffered eval and runs on PHP 8.

What else does the archive claim?

The same archive holds swarm logs for 76 anonymized targets. Payments, fintech and Web3 firms make up more than half. One task records 2,178 worker runs against a Southeast Asian crypto exchange.

Defender kit

Indicators of compromise

Verified adversary infrastructure and tool hashes from this study. Every value below is also discussed in the report.

IDTypeIndicatorPortContextAction
R30-IOC-01 SHA-256 20745360f904db566a373ce39bb05ea52fee24c5f6a404db756e9c5aecb1981e deploy_gcs_webshell.py · GCS-to-WordPress pax_cmd deployer, iteration 1 Hunt
R30-IOC-02 SHA-256 17c96f2ab239b6fd5b5454aae51301bee2021f0b8d9726c567c48b8ab167fbdc deploy_gcs_webshell2.py · GCS-to-WordPress pax_cmd deployer, iteration 2 Hunt
R30-IOC-03 SHA-256 d0c6e2776390e00684969931b003047b5f5b7c483e1cf263320d8181bbab94fc shell.php · Behinder-compatible AES-128/XOR web shell, version 1 for PHP 7 (569 B) Block
R30-IOC-04 SHA-256 67e9658391a17bc1e8dd23250bd5b99d4ef5c2e0f63d08f3c3a8abe61925c8bc shell2.php · Behinder-compatible AES-128/XOR web shell, version 2 for PHP 8 (755 B) Block

26 records from this study are not published in this table: candidate, suspected and dual-use hosts, victim-related values, and hashes of exposed secrets or files.

Defender kit

Detection rules

The rule files exactly as printed in the report. Test them in your own engine before deployment.

YARA odin_pax_cmd_deployer_and_behinder_twin_artifacts.yar 81 lines
Download
Suricata odin_pax_cmd_gcs_wordpress_backdoor.rules 21 lines
Download
Sentinel KQL sentinel_gcs_theme_overwrite_and_pax_cmd_hunt.kql 40 lines
Download
Sigma sigma_gcs_sa_key_abuse_and_cms_webshell_deploy.yml 105 lines
Download