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.
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.
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.
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
- 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.
- 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.
- Layer web, cloud-audit and PHP runtime controls. Block
pax_cmdrequests, 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
| Number | What it is |
|---|---|
| 29 | Code files on nine open web directories (21 unique SHA-256 digests) |
| 2 | Versions of the Python bucket-to-WordPress playbook (5,251 and 5,480 bytes) |
| 2 | Behinder-compatible PHP webshells, one for PHP 7 and one rebuilt for PHP 8 |
| 15 | Third-party package files among the 29, which yield 13 strings that look like domains but are not |
| 1,231 | Worker runs the archive records for its iGaming task, the one behind the playbook |
| 2,178 | Worker runs the archive records for its crypto-exchange task |
| 731 | Nodes (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.

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.
| Class | Files | Unique SHA-256 | Hosts | Size range (bytes) | What it is |
|---|---|---|---|---|---|
| Offense playbook | 2 | 2 | 1 | 5,251 to 5,480 | Bucket-to-WordPress pax_cmd deployers for the iGaming task |
| Webshell pair | 2 | 2 | 1 | 569 to 755 | Behinder-compatible AES-128/XOR PHP 7 and PHP 8 webshells |
| Operator utilities | 4 | 3 | 2 | 1,421 to 28,367 | A CVE-2026-109618 calibration script, a key generator and a rule generator |
| Agent and bot code | 6 | 6 | 3 | 3,933 to 28,633 | AI coding-agent folders and chat-bot scripts |
| Package files | 15 | 8 | 3 | 2,976 to 43,572 | telnetlib3, numpy, pip and a mini-program UI component |

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 role | Files | Unique SHA-256 | Main contents |
|---|---|---|---|
| Python package host | 10 | 5 | Python 3.13 telnetlib3 files in lib and lib64 |
| Bot host | 6 | 4 | Two Python bot modules with numpy and pip |
| AI agent host | 3 | 3 | Hermes agent folders and an Orca terminal shell hook |
| Archive host | 2 | 2 | deploy_gcs_webshell.py and deploy_gcs_webshell2.py |
| Webshell host | 2 | 2 | /serve/shell.php and /serve/shell2.php |
| Utility host | 2 | 2 | A key-generation script and a rule-generation script |
| CVE calibration host | 2 | 1 | /CVE-2026-109618/tools/calibrate.py (two copies) |
| UI component host | 1 | 1 | One mini-program JavaScript component |
| Chat-bot host | 1 | 1 | One 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.

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 written | What it does |
|---|---|
Theme 404.php | Replaces 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.php | WordPress 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.
| Attribute | Version 1 (deploy_gcs_webshell.py) | Version 2 (deploy_gcs_webshell2.py) |
|---|---|---|
| Size and length | 5,251 bytes, 137 lines | 5,480 bytes, 126 lines |
| Key input | i21899/gcs_service_account.json | i21899/gcs_service_account.json |
| PEM parsing | Strips newlines, breaks RS256 | re.DOTALL, keeps newlines |
| Token request | jwt-bearer, 3,600 s, storage and cloud scopes | Same |
| Objects uploaded | Theme 404.php and functions.php | Theme 404.php and Base64 functions.php |
| Probe paths | Theme 404.php?pax_cmd=id, /wp-content/404.php?pax_cmd=id, /pax_cmd.php?pax_cmd=id | Theme 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.
| File | Size | Lines | How it runs code | PHP versions |
|---|---|---|---|---|
/serve/shell.php | 569 bytes | 25 | create_function | PHP 7 only |
/serve/shell2.php | 755 bytes | 35 | ob_start and eval, encrypted output | PHP 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.

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 archive | What it says |
|---|---|
| Linked-server SQL injection | A 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 webshell | An unauthenticated PHP webshell was placed on a NAS backup mount reachable from the database network |
| Workstation cloud key | A 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 lists | Cached 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.
- 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.aspxand 16 secrets. A pair of controllers on LUCIDACLOUD hosting shares 714 endpoint hashes. - Sector focus. The iGaming playbook fits four Russian-language casino and compliance Telegram bots and four Telegram control groups found in public sources.
- 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 metric | Count | What it means |
|---|---|---|
| Nodes and edges | 731 / 795 | Includes 76 strong cross-host links |
| Documented access surfaces | 271 | Drop sites, bot and config credentials, templates, panels and databases |
| Exposed Python HTTP servers | 634 | The same open-directory pattern as the archive host |
| Shared endpoint hashes, LUCIDACLOUD pair | 714 | Dense overlap between two paired controllers |
| Shared secrets, Tencent trio | 16 | Alongside a byte-identical shell.aspx on three hosts |
| Exposed AI agent-session hosts | 112 | Hosts that leak agent transcripts or workspace folders |
| Telegram artifacts from public sources | 4 + 4 | Four 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.

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.
| Sector | Scopes | Share | Subdomains | Key task or bucket evidence |
|---|---|---|---|---|
| Payments and Fintech | 21 | 27.6% | 3,910 | Production and development buckets (names withheld) |
| Web3, DeFi and Stablecoin | 20 | 26.3% | 3,420 | Multi-worker subdomain and API reconnaissance |
| Enterprise Tech and SaaS | 11 | 14.5% | 2,180 | Cloud workbench and SaaS tenant enumeration |
| iGaming and Online Casino | 10 | 13.2% | 1,890 | The iGaming task (1,231 runs) and the bucket playbook |
| Banking and Insurance | 8 | 10.5% | 1,410 | Banking and CDN buckets (names withheld) |
| Crypto Exchanges | 6 | 7.9% | 1,054 | The crypto-exchange task (2,178 runs) and backup bucket claims |
Four ways to read the evidence
- Package noise. Raw string matching over
site-packagesand 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. - An authorized test gone wrong. Task-numbered folders, structured
penetration_test_report.mdoutputs and a pentest-named service account in the crypto-exchange task fit a contracted red team misconfiguring an ARTEX server. Even so, an unauthenticatedpax_cmdgate in a live theme file exposes the site to anyone, and needs urgent remediation. - 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.
- 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 onDATA_WRITEaudit logs for those buckets. - Allow theme-folder writes only from named CI/CD service accounts. Alert on any
application/x-phpobject written by anyone else.
Cloud IAM
- Revoke long-lived user-managed service-account keys on workstations. Enforce
constraints/iam.disableServiceAccountKeyCreation. - Remove
roles/editorfrom CI and developer accounts. Review OAuthjwt-bearertoken requests from hosts outside Google Cloud.
CMS and platform
- Record hashes of the deployed
404.phpandfunctions.phpfor every theme, and alert on drift. Mount core and theme code read-only on origin containers. - Set
disable_functions = system,passthru,exec,shell_execinphp.iniwhere 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_cmdin 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 file | What it catches |
|---|---|
odin_pax_cmd_gcs_wordpress_backdoor.rules | Suricata 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.kql | Microsoft 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.yml | Sigma (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.yar | YARA (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
| SID | Looks for | Why |
|---|---|---|
| 9530001 | pax_cmd= in an inbound request URI | Catches use of the injected gate through a query string (block candidate) |
| 9530002 | pax_cmd= in an inbound POST body | Catches the same gate through a form body (block candidate) |
| 9530003 | A direct request for any theme's 404.php or functions.php | Normal visitors never request these files by path |
| 9530004 | Outbound POST /upload/storage/v1/b/ with uploadType=media, a wp-content path and Content-Type: application/x-php | Catches a PHP theme write to Cloud Storage (needs TLS inspection) |
| 9530005 | Outbound POST to oauth2.googleapis[.]com with a jwt-bearer grant and an assertion | Hunt only: flags token requests from hosts where cloud SDKs should not run |
| 9530006 | Outbound GET for deploy_gcs_webshell.py or deploy_gcs_webshell2.py | Catches retrieval of the playbook |
| 9530007 | Inbound request for /serve/shell.php or /serve/shell2.php | Catches access to the twin webshell paths |
| 9530008 | A directory listing that names the deployer, the key file or CVE-2026-109618 | Catches 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 rule | Fires when |
|---|---|
ODIN_GCS_WordPress_PaxCmd_Deployer_Playbook | A Google OAuth token marker appears with devstorage.full_control, uploadType=media and either a theme path or pax_cmd |
ODIN_WordPress_PaxCmd_Injected_Theme_Gate | pax_cmd and _REQUEST appear with two of system, passthru and shell_exec |
ODIN_Behinder_AES128_XOR_Twin_PHP_Webshell | AES128, openssl_decrypt and the XOR index marker appear with create_function or ob_start |
ODIN_GCS_SA_Workspace_and_Probe_Artifact | Two 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
| Tactic | Technique | How the chain uses it | Detection |
|---|---|---|---|
| Defense Evasion, Persistence | T1078.004 Valid Accounts: Cloud Accounts | A stolen service-account key signs in to Google Cloud | SID 9530005; KQL; Sigma rule 1 |
| Credential Access | T1528 Steal Application Access Token | The key is traded for a one-hour bearer token with full storage rights | SID 9530005; Sigma rule 3 |
| Persistence | T1505.003 Server Software Component: Web Shell | pax_cmd theme gate and the Behinder twin webshells | SIDs 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.
| Type | Count | Where to use it |
|---|---|---|
| Network addresses | 0 | All host addresses are withheld |
| File hashes (SHA-256) | 4 | EDR and file-integrity scanning |
| Web request parameter and probe URIs | 4 | WAF rules and web access logs |
| Cloud API patterns | 3 | Cloud audit logs and TLS egress proxies |
| Workspace file path | 1 | Endpoint command-line and file hunting |
File hashes
| File | Size (bytes) | SHA-256 | Use |
|---|---|---|---|
deploy_gcs_webshell.py (version 1) | 5,251 | 20745360f904db566a373ce39bb05ea52fee24c5f6a404db756e9c5aecb1981e | Hunt on workstations and servers |
deploy_gcs_webshell2.py (version 2) | 5,480 | 17c96f2ab239b6fd5b5454aae51301bee2021f0b8d9726c567c48b8ab167fbdc | Hunt on workstations and servers |
/serve/shell.php | 569 | d0c6e2776390e00684969931b003047b5f5b7c483e1cf263320d8181bbab94fc | Block in web roots |
/serve/shell2.php | 755 | 67e9658391a17bc1e8dd23250bd5b99d4ef5c2e0f63d08f3c3a8abe61925c8bc | Block in web roots |
Other indicators
| Indicator | Type | Use |
|---|---|---|
pax_cmd | Query or POST parameter | Block at the WAF |
/wp-content/404.php?pax_cmd=id | Probe URI (version 1 fallback) | Block at the WAF |
/pax_cmd.php?pax_cmd=id | Probe URI (version 1 root fallback) | Block at the WAF |
/?pax_cmd=id | Probe URI (version 2 functions.php check) | Block at the WAF |
oauth2.googleapis[.]com/token with grant type jwt-bearer | Cloud API pattern | Watch, do not block the domain |
devstorage.full_control scope | OAuth scope | Watch in IAM logs |
storage.googleapis[.]com/upload/storage/v1/b/*/o?uploadType=media | Cloud API pattern | Hunt for PHP writes |
i21899/gcs_service_account.json | Workspace file path | Hunt 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_cmdprobe 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
- 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)
- Google Cloud Storage. JSON API v1, Objects: insert. https://cloud.google.com/storage/docs/json_api/v1/objects/insert (verified 20 November 2026)
- Google Identity. Using OAuth 2.0 for server to server applications. https://developers.google.com/identity/protocols/oauth2/service-account (verified 20 November 2026)
- WordPress Developer Resources. Theme Handbook: Template Hierarchy. https://developer.wordpress.org/themes/basics/template-hierarchy/ (verified 20 November 2026)
- MITRE ATT&CK. T1078.004 Valid Accounts: Cloud Accounts. https://attack.mitre.org/techniques/T1078/004/ (verified 20 November 2026)
- MITRE ATT&CK. T1505.003 Server Software Component: Web Shell. https://attack.mitre.org/techniques/T1505/003/ (verified 20 November 2026)
- MITRE ATT&CK. T1528 Steal Application Access Token. https://attack.mitre.org/techniques/T1528/ (verified 20 November 2026)
- 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.
What is pax_cmd?
pax_cmd is the request parameter used by a WordPress theme backdoor described in Monograph 30. Any request carrying it can run commands on the server.
More about pax_cmdWebshell managerWhat is Behinder?
Behinder is a public Chinese webshell manager that encrypts its traffic to evade inspection.
More about BehinderAI offensive toolWhat is ARTEX?
ARTEX is an autonomous red-team console that chains AI agents and security tools. Operators fork and rebrand it; its default listener port is 8787.
More about ARTEXTechniqueWhat is xp_cmdshell?
xp_cmdshell is a SQL Server extended stored procedure that runs operating system commands. Attackers enable it to move from database access to the host.
More about xp_cmdshellFrequently 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.