Files
ZSecurity d1a6f0ab32
ci / macos-latest / py3.12 (push) Canceled after 0s
ci / macos-latest / py3.9 (push) Canceled after 0s
ci / ubuntu-latest / py3.12 (push) Canceled after 0s
ci / ubuntu-latest / py3.9 (push) Canceled after 0s
ci / windows-latest / py3.12 (push) Canceled after 0s
ci / windows-latest / py3.9 (push) Canceled after 0s
refactor: ship the exploit client only; drop the bundled lab harness
- remove lab/ (index.php, apache conf, up/down/status shims)
- remove poc/lab.py and the 'poc lab' subcommand
- proof path defaults to a fixed per-user dir so the working directory no longer matters
- README: target recipe documented instead of shipped
2026-10-24 15:02:47 +07:00

389 lines
22 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 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](#target-not-shipped)). 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](https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w),
[GHSA-6wmf-4rv5-p3rp](https://github.com/php/php-src/security/advisories/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](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
```bash
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](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/*.sh` files 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:
```bash
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 `/out` mount which matches the client's proof directory
Minimal target, two files plus a container. `index.php`:
```php
<?php echo "OK\n";
```
`apache-single-worker.conf`:
```apache
KeepAlive Off
<IfModule mpm_prefork_module>
StartServers 1
MinSpareServers 1
MaxSpareServers 1
MaxRequestWorkers 1
ServerLimit 1
MaxConnectionsPerChild 0
</IfModule>
```
```bash
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:
```bash
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`:
```bash
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 `--workers`
occupies `N-1` children; 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 check` and `poc status` work by `docker exec`, so
they only apply to the local container — for a remote host, obtain its `libphp.so`, verify the
SHA-256, run `python -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=0` and
`session.upload_progress.enabled=On` are 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:
```bash
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`:
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
```
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](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.