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:

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

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%