PHP2Shell exploitation observed on 24 October 2026 is a honeypot record, not a victim list. Sensors correlated 35 complete execution-stage HTTP POSTs with 35 /bin/sh processes started directly by Apache workers on PHP 8.4.26. It is packet-to-process evidence of remote code execution, and it shows why an HTTP 200 on the early stages is the wrong signal for whether a PHP site was actually hit.
Key takeaways
- Thirty-five execution-stage HTTP POSTs on 24 October 2026 lined up with 35 /bin/sh processes whose parent was an Apache worker running as uid 33, on three PHP 8.4.26 honeypots.
- HTTP 200 on the memory-pressure and disclosure stages is not success. The worker often died on the execution stage and never wrote that access-log line.
- The chain is four multipart stages: memory pressure, an 800 KiB PHPSESSID disclosure, more memory pressure, then a body adjusted to the leaked addresses and the shell command.
- The traffic is consistent with CVE-2026-109618 and the public HTTP-only PHP2Shell family. Two source-address clusters shared the early bodies; that is related tooling, not two named actors, and it does not establish CVE-2026-109619, a patched version, or any production victim.
What does PHP2Shell exploitation observed on 24 October actually confirm?
On 24 October 2026, honeypot sensors tied 35 complete execution-stage HTTP POSTs to 35 /bin/sh starts. Each shell’s parent was an Apache worker. All 35 shells ran as uid 33 on three PHP targets the report labels T1, T2, and T3. The targets were disposable honeypots that presented ordinary PHP-backed pages. The dataset measures what reached those sensors. It is not a list of breached companies.
Six sensors supplied the collection. The acquired snapshot held 3,459 sealed segments and 10,948 manifest-listed files, 11.21 GB. Every listed size and SHA-256 matched the local copy. Parsed Apache and Tetragon JSONL contained no malformed lines. The latest sealed window on each sensor ended between 19:26 and 19:31 UTC. Every count below refers to that fixed snapshot.
Analysts joined packet flows, Apache worker PIDs, PHP errors, and Tetragon process events by source port, time, worker identity, and request sequence. The authors required the execution-stage POST and the shell’s parent PID to describe the same worker. That join is the 35-to-35 match.
Each target ran PHP 8.4.26 under single-worker Apache mod_php, with a 128 MiB PHP memory limit (134,217,728 bytes). Every confirmed execution-stage request used plaintext HTTP on port 80, so request bodies could be rebuilt from packet capture. An HTTPS-only site needs endpoint telemetry, or decrypted traffic, before an analyst can rebuild bodies the same way.
Relevant PHP errors fired during request startup, reported as Unknown on line 0, before application code. That timing fits a PHP-engine issue rather than a defect in one CMS or plugin. mod_php runs PHP inside the Apache worker, so each confirmed shell’s parent was apache2. A site on PHP-FPM should expect an equivalent shell to descend from a php-fpm worker. The report names no production victims, no fixed PHP build, and no exact exploit client.
Why is HTTP 200 the wrong success signal for PHP2Shell?
HTTP 200 on the early stages is not the success criterion. The confirmed signal is an Apache worker starting /bin/sh. The authors required a /bin/sh whose parent was the Apache worker that accepted the execution-stage POST. uid 33 keeps the initial privilege at the web account, which can still read application files, database credentials, and cloud keys in config, and can reach whatever the web tier can reach on the internal network.
The chain has four multipart stages, sometimes with retries. A1 applies memory pressure. B1 tries to disclose memory through an oversized PHPSESSID. A2 applies further memory pressure. B2 is the execution stage, and its body changes with leaked address-like values and the shell command. The report reads that pattern as leak-guided adjustment under ASLR, a published technique, rather than a new primitive. Decoded sizes, excluding HTTP chunk framing, separate the stages on a representative complete T1 chain at 15:35 UTC. The same first three decoded bodies appeared in complete successful-chain captures from both source clusters and all three targets.
| Stage | Shape | Decoded body | Observed effect |
|---|---|---|---|
| A1 memory pressure | Chunked multipart POST | 1,060,211 bytes | memory_limit exhausted in Unknown on line 0; tried to allocate 4,096 bytes; access log completed HTTP 200 |
| B1 disclosure | Chunked multipart POST | 33,128,677 bytes | 819,200-byte URL-decoded PHPSESSID in a complete response; session-startup warnings |
| A2 memory pressure | Fixed-length multipart POST | 279,369 bytes | memory_limit exhausted in Unknown on line 0; tried to allocate 20,480 bytes |
| B2 execution | Fixed-length multipart POST | 451,384 bytes | No normal access-log completion; Apache-parent /bin/sh; worker then SIGSEGV |
The B1 disclosure body (33,128,677 bytes, about 33 MB) is roughly 73 times the B2 execution body (451,384 bytes, about 451 KB). A large-POST alert can flag disclosure and miss the smaller request that runs a command. A1 and B1 used Transfer-Encoding: chunked. A2 and B2 used Content-Length. The operator sometimes repeated A1 and B1 before advancing.
The report logged 52 disclosure-sized cookies. Each decoded value was 819,200 bytes, exactly 800 KiB, and contained repeated, aligned, pointer-like 64-bit words. In representative leaks, one dominant word was repeated 1,095 times. By episode the 52 cookies split as three on T1 for the first source cluster, and four on T1, 29 on T2, and 16 on T3 for the second. T1’s seven cookies are why that target’s complete-response tally is 7 of 7.
Analysts matched the SHA-256 of each cookie value, as Apache logged it, to the target-side packet capture. That match reconstructed 51 complete responses, with zero captured response gaps and a client ACK through the response end: 7 of 7 on T1, 28 of 29 on T2, and 16 of 16 on T3. The remaining T2 capture begins mid-response. Apache still recorded that cookie. Treat that one as logged, not as a fully reconstructed delivery.
A1, B1, and A2 produced HTTP 200 or a normal access-log line. B2 could start a shell and then crash the worker, so Apache never wrote the access line for the request that mattered. A child that dies on signal 11 skips that completion path. The first confirmed T1 execution is a clock. The B2 POST began at 15:35:38.238 UTC from the first source cluster. At 15:35:38.673 Tetragon recorded apache2 starting /bin/sh as uid 33, and that shell starting /usr/bin/id. Apache child PID 31 exited on segmentation fault, signal 11, at 15:35:39.379. Apache had logged A1, B1, and A2 on the same worker, container PID 31.
Two further source addresses sent exploit-shaped requests associated with PHP errors or worker crashes in the same snapshot. Neither had an observed Apache-parent shell or a disclosure-sized cookie. The report classifies them as attempt indicators. A crash or a PHP error alone did not meet the authors’ threshold for confirmed remote code execution. The same B1 disclosure body also appeared in attempt-only captures. That digest identifies a payload family. It does not, by itself, mark an execution outcome.
After the shells started, commands shifted among PHP CLI, curl, and wget. Later proof URLs embedded shell command substitutions for id -un, hostname, and uname -m. On the first T1 chain the command tried to write id output to a temporary proof file and to web roots, then invoke wget. The web-root writes met a read-only filesystem. wget was absent. Apache logged “Read-only file system” for the web-root attempts and “wget: not found” for the attempted fetch. Both results blocked a particular delivery step. Neither undid the code execution. Look next at .env files, database DSNs, API tokens, and cloud metadata the instance role will hand out. Restarting Apache removes the crashed worker and leaves those secrets where they were.
Path probing on Episode A began at 13:47 UTC. Memory-pressure requests were underway by about 15:16. The first confirmed Apache-parent shell landed at 15:35. Two further shells followed at 16:04. All three used the same final-stage request-body hash and the same shell command: an id proof file, web-root writes, then wget. Episode B appeared at 16:36 UTC with disclosure-sized responses, cycled through repeated out-of-memory, leak, and crash attempts around 16:44–16:46, and produced its first confirmed shell at 16:46. Tetragon then recorded 32 Apache-parent shell starts through 18:57: 19 on T2, 10 on T3, and 3 on T1. Of the 35 confirmed shells, three belong to the first source-address episode and 32 to the second.
Representative complete chains from both source clusters and all three successful targets shared byte-identical A1, B1, and A2 bodies. Only B2 changed, with the target’s leaked address range and the shell command. On the representative T1 chain, A1 was dominated by files* parts, 859 of 973. B1 had 900 x* fields among 918 parts. A2 had 880 files* fields among 997. B2 had 500 s* and 495 t* fields among 998, plus target-dependent address-like words and a command string. All four stages included PHPSESSID and PHP_SESSION_UPLOAD_PROGRESS fields. The report publishes the early-body digests. This article does not repeat them.
Does CVE-2026-109618 cover this traffic, and are two clusters two actors?
The defensible finding is two source-address episodes that used closely related tooling. The report states the limit in plain language: these are two source-address clusters, not an attribution to two actors. One cluster produced three shell events, all on T1, from 15:35 through 16:04. The other produced 32 shell events across T1, T2, and T3, from 16:46 through 18:57. A shared template and the same stage order do not establish shared control. Different source addresses and different proof commands do not establish separate actors either.
Both confirmed addresses were registered to United States hosting when they were checked on 24 October. One fell in OVH US LLC address space, 15.204.0.0/16. The other fell in Interserver, Inc address space, 162.35.96.0/19. The OVH address had a PTR, vps-b225fb62.vps.ovh.us, that resolved back to the same IP. The Interserver address had a PTR, vps3749638.trouble-free.net, with no confirming A record in the lookup. Network registration and reverse DNS describe the infrastructure that carried the packets. They do not name who operated the virtual machines.
A public exploit.py revision examined on 24 October filters disclosed pointers below 0x7f0000000000. The early successful chains had no pointer-like words above that threshold in their observed cookies, so an unchanged run of that revision would not parse those leaks. Two later T3 cookies did contain qualifying pointers. The traffic therefore does not support a blanket claim that every successful run required a modified proof of concept. Packet captures cannot identify which implementation was used.
The observed chain is consistent with CVE-2026-109618. These records do not establish use of a distinct CVE-2026-109619 path. Treat CVE-2026-109619 as unconfirmed until a record actually demonstrates that path. The public 9bie HTTP-only proof of concept uses the same type of relative address calculation and the same request roles: pressure, disclosure, more pressure, then a target-adjusted execution stage. Wiz’s PHP2Shell research describes the underlying PHP upload-progress and memory-disclosure family. The honeypot traffic closely matches that public HTTP-only proof-of-concept family. Packet evidence does not identify the exact client or revision the operators ran.
ASLR moves mappings when a worker starts. The disclosure stage supplies current addresses so the execution stage can be recalculated for that process. On representative leaks the dominant disclosed pointer differed in absolute value across T1, T2, and T3. An address-like word in the matching B2 body kept the same relative difference from that value on each target. The execution stage was rewritten to the leak.
The report gives no CVSS score for either identifier. It gives no patched version and no affected-version matrix beyond the build that was listening: PHP 8.4.26, Apache mod_php, one worker, a 128 MiB memory_limit, and plaintext port 80. Do not invent a safe minor version from this honeypot record. Track the PHP project’s advisory for CVE-2026-109618, and apply the vendor fix on the build Apache or PHP-FPM actually loads once that advisory names one. A standing vulnerability management practice is how that advisory reaches the hosts that serve PHP, not only the CLI binary someone prints from a login shell.
The report also publishes source-address indicators and decoded-body digests for the fixed early stages. This article does not repeat those IP addresses or hashes. No production sector appears in the dataset. Hits on machines that merely looked like PHP on port 80 show the request pattern in use. They do not say which industry is under fire this week.
What should a PHP site owner check this week?
Check whether apache2, httpd, or php-fpm has spawned a shell, PHP CLI, curl, or wget. Treat that parentage as a compromise even when the access log shows HTTP 200 or shows nothing for the last request. The checks below follow the honeypot evidence. They are not a claim that every PHP 8.4 site was breached on 24 October.
Hunt the stack you actually serve
Start with the PHP that Apache or PHP-FPM loads, not the CLI binary on a login PATH. apachectl -M 2>/dev/null | grep -E 'php|mpm' shows whether mod_php is loaded and which MPM you run. php -v and php --ini document the CLI build only. Open the ini and pool config that Apache or php-fpm actually loads, and record the memory_limit that worker uses. The honeypots ran 128 MiB. Your number can differ, and the worker’s value is the one that matters, including session upload-progress settings in that same file.
Hunt processes, then the lines that never got written
While the host is up, ps -eo user,pid,ppid,comm,args --forest shows shells, PHP CLI, curl, or wget under apache2, httpd, or php-fpm. ss -tpn shows current outbound connections. A quiet table at 09:00 does not clear activity from 15:35 the day before.
If you export Tetragon, auditd, or an EDR process feed, search exec events whose parent is the web runtime and whose child is a shell, PHP CLI, curl, or wget. On this dataset every confirmed shell ran as uid 33. On many Linux images that uid is named www-data, so search both the numeric id and the local account name. Start with 24 October 2026, then widen the window, because this HTTP-only tooling is already public. SIEM and log monitoring is how a segfault, a POST, and a process exec stay on one timeline.
On Debian and Ubuntu, search Apache logs for segmentation faults, “Read-only file system,” “wget: not found,” and POSTs to / or /index.php. On RHEL-family hosts, use the same patterns under /var/log/httpd/. A fault on an Apache child in the same second as one of those POSTs deserves a process timeline. Those error strings mean a command ran far enough to fail. Pair them with parentage before you call the event confirmed.
Request traits you can put in a hunt
Confirmed requests were HTTP/1.1 multipart POSTs to / and /index.php. They carried no User-Agent header and used a ten-character multipart boundary. Chunked stages ordered headers Host, then Content-Type, then Transfer-Encoding, then Connection. Fixed-length stages ordered Host, Content-Type, Content-Length, Connection. The first memory-pressure request carried five numbered q query parameters. Early stages can return HTTP 200 while exhausting memory_limit at startup, with the error in Unknown on line 0. Use the traits to find candidates, then confirm with process parentage.
Preserve, then recover
Copy packet captures if you have them, plus Apache and PHP logs and process-telemetry exports, before a restart or a rebuild. Log rotation and systemctl restart apache2 destroy the link between a source port and a PID. A missing access-log line may be the crash artifact.
List new web files without changing them. A read-only find for paths under the document root newer than 2026-10-24 is enough to see what appeared that day. Match hits to your deploy records. A PHP file you did not ship is a lead. It is not required for the incident to be real: these honeypot shells were confirmed before any web-root write succeeded.
If the parentage is there, isolate the host. Assume secrets the web account could read are exposed. Rotate database passwords, API keys, and session secrets that lived on that machine, and rebuild from a known image. Threat hunting is the work of walking parent PIDs, uid, and file times without trampling that evidence. Once execution is confirmed, compromised server recovery is the rebuild, and the rotation of whatever the web account could read.
These were disposable honeypots. The 35 shells are not a count of breached production companies. The targets ran PHP 8.4.26 on single-worker mod_php, plaintext HTTP, and a 128 MiB memory limit. A site on PHP-FPM behind TLS, or on a different 8.4 patch, was not measured here. Thirty-five execution-stage POSTs lined up with thirty-five Apache-parent shells, uid 33, on 24 October 2026. The chain matches the public HTTP-only PHP2Shell family and is consistent with CVE-2026-109618.
FAQ
What is PHP2Shell and is it being exploited?
PHP2Shell is the public name for an HTTP-only PHP attack that uses upload-progress handling and a memory disclosure to adjust a later request to the worker’s addresses, then run a command. On 24 October 2026 honeypot sensors recorded 35 confirmed cases: each execution-stage POST matched an Apache-parent /bin/sh on PHP 8.4.26, on disposable honeypots, not named production victims.
Is CVE-2026-109618 the same as PHP2Shell?
The honeypot chain is consistent with CVE-2026-109618 and with the public HTTP-only proof-of-concept family, including the 9bie PoC’s relative address calculation and the request roles Wiz’s research describes. The records do not identify the exact client, and they do not establish a separate CVE-2026-109619 path.
Does an HTTP 200 mean a PHP exploit worked?
No. On these honeypots the memory-pressure and disclosure stages often completed with HTTP 200, including after PHP exhausted memory_limit during request startup. The execution stage could start /bin/sh and then crash the worker, so Apache never wrote an access line for the request that mattered.
How do defenders confirm Apache spawned a shell?
Join the execution-stage request to a process event whose parent is the Apache or PHP-FPM worker that accepted it. In this dataset Tetragon showed apache2 starting /bin/sh as uid 33, followed in the first case by /usr/bin/id, then a segmentation fault on that child. A PHP error or a worker crash alone was not counted as confirmed remote code execution.
If an Apache or PHP-FPM worker on your host has already started a shell, isolate the machine and work from preserved logs rather than a restart. SafetyBis can take that from parent-process evidence through compromised server recovery.
Tell us what you're running
Scoping is free. We reply within one business day, and under 30 minutes for active incidents.
