On 21 October 2026 the PHP project published an unscheduled security release covering two unauthenticated remote code execution issues: CVE-2026-109618 and CVE-2026-109619, each carrying a CVSS v4.0 base score of 9.2. The advisories shipped alongside patched branches — 8.5.12, 8.4.27, 8.3.36 and 8.2.35 — and by the time they were published at 14:00 UTC, watchTowr had already reproduced one of the issues and Cloudflare had confirmed exploitation in the wild. The nickname php2shell was circulating across every operational channel within minutes.
For teams running self-hosted infrastructure the first problem was not the exploit itself. It was the inventory: not every PHP surface in a fleet receives a patch, and one of ours never will. The second problem was timing. Patched upstream branches do not become patched container images and distribution packages instantaneously, and the gap between disclosure and usable fixes is exactly where an edge control has to earn its place.
This is how we contained the issue across a four-host web fleet fronted by Traefik, by refusing multipart POSTs at the reverse proxy. One of those hosts was running PHP 7.4, which reached end of life in November 2022.
Technical detail was embargoed until the patch release, but the operational picture settled quickly:
| Fact | Detail |
|---|---|
| CVEs | CVE-2026-109618, CVE-2026-109619 |
| Severity | CVSS v4.0 base score 9.2 each (PHP security team) |
| Impact | Unauthenticated remote code execution |
| Affected | All PHP versions from 5.x onwards, per CERT-EU |
| Fixed | 8.5.12, 8.4.27, 8.3.36, 8.2.35 (21 Oct 2026, 14:00 UTC) |
| End-of-life branches | 5.x–8.1.x: no fix will ever be issued |
| Exploitation | Early attacks confirmed by Cloudflare ahead of the release |
The detail that matters operationally is the delivery mechanism. Early reporting converged on PHP's session upload progress mechanism, reached through multipart request handling. The exploit therefore arrives as a multipart/form-data POST, which a reverse proxy can identify from the Content-Type header alone, without inspecting the request body. That property is what makes edge containment viable at all.
Two PHP core developers characterised the available options bluntly: "ini settings won't save you" and "the only mitigation is patching or upgrading PHP." CERT-EU's guidance for systems that cannot be patched immediately was isolation from the public internet. Our approach was narrower — edge filtering for surfaces awaiting a patched build, and outright retirement for the one surface that would never receive one.
Before deploying any control we inventoried what was actually exposed. The sweep checked system PHP packages, running php-fpm processes, container image inventories, and live service and listener state.
| Surface class | Example | Version | Exposure | Status |
|---|---|---|---|---|
EOL system PHP via Apache mod_php | legacy ActiveSync gateway | 7.4.3 | formerly public | No patch will ever exist |
| Vendor container lagging upstream | mailcow phpfpm image | 8.2.29 | Public (webmail) | Patchable once the image rebuilds |
| Self-built application container | Invoice Ninja (PHP bundled) | 8.2.28 | Public | Patch pending upstream rebuild |
| Internal-only container | Nextcloud (nextcloud:apache) | 8.5.10 | Docker network only, no published ports | Not internet-facing |
| Hosts without PHP | — | — | — | Clean |
Two findings from this exercise generalise beyond our fleet.
One nominally web-facing mod_php stack turned out to be a masked, non-running Apache unit — dead weight rather than attack surface. Verify systemctl is-active, is-enabled and is-masked, and cross-check the result against ss -tlnp and the routes the reverse proxy actually serves. The questions that matter are what listens, what starts at boot, and what the proxy routes.
PHP 7.4 will not receive an emergency release. For that surface an edge block is not a stopgap — it is the permanent control until the stack is upgraded or retired. We retired it: the entire Apache + mod_php + z-push stack was purged from the host on the same day. When the application is gone, the fastest fix is to remove the interpreter rather than shim it.
All four public hosts front their services with Traefik v2.11, which provides a single point of control. The control is a file-provider router with a priority above every other router, matching multipart POSTs and routing them into Traefik's built-in noop@internal service. That service answers with HTTP 418 and never reaches a backend.
http:
routers:
php2shell-block-multipart:
rule: >-
Method(`POST`) && HeadersRegexp(`Content-Type`, `(?i)^multipart/`)
entryPoints: ["websecure", "web"]
priority: 10000
service: noop@internal
tls: {}
Deploy this to the dynamic configuration directory — /etc/traefik/dynamic/routers-php2shell.yml on a standard mount — and recreate the Traefik container.
Both failures below left the deployment pipeline reporting success while the router was absent from the routing table entirely.
Entrypoint names must match the deployment. The documented examples use http and https; this fleet uses web and websecure. A router referencing a non-existent entrypoint fails with entryPoint "https" doesn't exist in the Traefik log and is silently missing from routing. Read traefik.yml before deploying.
The matcher is HeadersRegexp, not HeaderRegexp. The singular form does not exist in Traefik OSS and produces unsupported function: HeaderRegexp — again in the log only, again with the router absent from the routing table. The plural form is correct for v2.11.
Verify against the log, not the exit code. The only reliable signal is docker logs traefik | grep php2shell returning no output, followed by a synthetic request.
With the router in place, verification requires one request per traffic class:
# Blocked: multipart POST (the php2shell delivery vehicle)
curl -s -o /dev/null -w "%{http_code}\n" -X POST https://mail.example.org/ \
-H "Content-Type: multipart/form-data; boundary=----"
# → 418
# Unaffected: regular form POST
curl -s -o /dev/null -w "%{http_code}\n" -X POST https://mail.example.org/ \
-H "Content-Type: application/x-www-form-urlencoded"
# → 200
# Unaffected: GET
curl -s -o /dev/null -w "%{http_code}\n" https://mail.example.org/
# → 200
All four hosts returned 418 for multipart POSTs and passed every other request class through unchanged. ActiveSync traffic on the mail host — plain XML and URL-encoded POSTs from mobile mail clients — continued to work, because it does not use multipart encoding.
For the mailcow phpfpm container (8.2.29 at the time of writing) we also disabled session upload progress inside the container. This is not a mitigation for the vulnerability — the PHP core developers are explicit that it is not — but it removes a related code path at no cost while the upstream image is rebuilt:
PHP_FPM=$(docker ps --format '{{.Names}}' | grep -m1 php-fpm)
docker exec -u 0 "$PHP_FPM" sh -c \
'echo "session.upload_progress.enabled = Off" > /usr/local/etc/php/conf.d/zzz-php2shell.ini'
docker exec "$PHP_FPM" kill -USR2 1 # graceful php-fpm reload
docker exec "$PHP_FPM" php -i | grep upload_progress.enabled
# session.upload_progress.enabled => Off => Off
The zzz- prefix ensures the file loads last among the conf.d snippets. kill -USR2 1 reloads the php-fpm workers gracefully without restarting the container.
Blocking multipart breaks legitimate file uploads in every proxied application that uses multipart/form-data — webmail attachments, for example. Some applications are affected less than expected: Nextcloud uploads through its own chunked endpoint rather than multipart forms, and continues to function behind such a block.
For patchable surfaces this is a deliberate, temporary degradation with a defined exit condition. For an end-of-life PHP 7.4 surface the block would have become the control in its own right, which raises the question that actually matters: how long can a stack that will never receive another security patch remain on the public internet? In our case the answer was the same day.
One operational detail merits recording. Recreating Traefik with --force-recreate across four hosts in quick succession triggered a Let's Encrypt revalidation storm, and several domains hit the five-failed-authorisations-per-hour rate limit as challenge traffic stopped arriving correctly. The existing certificates remained valid — they had been issued months earlier — but any new issuance stalled for up to an hour. When recreating a shared reverse proxy during an incident, recreate it once, do it last, and expect ACME turbulence if the routers reference resolvers with pending challenges.
The upstream release is available, but the work is not complete when the patches are published. Container images and distribution packages lag the upstream branches, and end-of-life branches never catch up at all.
phpfpm:8.2.35-x, then re-evaluate removing the multipart block for that hostapache2 (masked and not startable), libapache2-mod-php7.4, all php7.4-* packages and the z-push* packages — was purged from the mail host. The vulnerable interpreter no longer exists on disk; there is nothing left to accidentally start. The Traefik block now guards containerised PHP only, namely the mailcow phpfpm image pending upstream rebuildWhen the mitigation sits at the reverse proxy, four hosts of PHP exposure collapse into a single YAML file — provided the operator already knows the entrypoint names, the real PHP inventory, and where to read the Traefik log. None of that can be reconstructed under time pressure during an active exploitation window. The inventory is the prerequisite for every other control, and it is the one artefact that cannot be assembled on demand. Build it before the disclosure, not during it.