CVE-2026-129289 lets an attacker smuggle a second FastCGI request into PHP-FPM, but only when the web server in front of PHP keeps its backend connections open between requests. That one front-end setting, not the PHP version alone, decides whether this critical bug is reachable on your server. The fix shipped on 19 November 2026 in PHP 8.5.13, 8.4.28, 8.3.37 and 8.2.36.
The PHP project rated the flaw critical, with a CVSS 4.0 score of 9.2 in its security advisory. Red Hat scores it lower, 8.1 under CVSS 3.1, and calls that score preliminary. The same release fixed a second critical bug in session handling, CVE-2026-115560, covered further down.
Am I affected by CVE-2026-129289?
You are exposed if three things are true at once: your PHP is older than the fixed release for its branch, the web server or proxy in front of PHP-FPM (the FastCGI Process Manager that runs PHP for most nginx and many Apache setups) reuses connections to it, and some application on the box opens the raw request body without reading all of it. The advisory is explicit that no unusual PHP setting is needed. The risky part is the front end.
| PHP branch | Vulnerable | Fixed in |
|---|---|---|
| 8.5 | 8.5.0 to 8.5.12 | 8.5.13 |
| 8.4 | 8.4.0 to 8.4.27 | 8.4.28 |
| 8.3 | 8.3.0 to 8.3.36 | 8.3.37 |
| 8.2 and older | before 8.2.36 | 8.2.36 |
In plain numbers: 8.5.0 to 8.5.12, 8.4.0 to 8.4.27 and 8.3.0 to 8.3.36 are vulnerable, as is everything before 8.2.36. The advisory says, based on code inspection, that the bug goes back to PHP 5.6.0. PHP.net shipped fixes only for the four supported branches, so a server still on 8.1 or older has no upstream release to install and needs the configuration mitigation below or a vendor backport.
How the smuggling works, at the level a defender needs
When a PHP script opens php://input, the stream that holds the raw HTTP request body, and stops reading before the end, PHP leaves the unread bytes sitting on the connection when the request finishes. On a connection that closes after every request, those bytes die with it. On a connection the front end keeps alive for the next visitor, PHP-FPM reads the leftovers as the start of a brand new FastCGI request.
That is where the severity comes from. According to the advisory, an attacker who controls those bytes can set the parameters the web server normally sets on PHP's behalf: SCRIPT_FILENAME (which file runs), REMOTE_ADDR (which client IP the application believes it is talking to), and PHP_ADMIN_VALUE (the channel FPM uses to apply PHP settings). Aikido's analysis of the release says that in this setup the result can be running PHP code as the worker user. Red Hat's CVE page describes the impact more conservatively, as security control bypass, cache poisoning or request manipulation.
Our read: the forged REMOTE_ADDR deserves more attention than it is getting. Plenty of admin panels, XML-RPC endpoints and rate limiters on shared hosting trust the client IP that PHP reports. Even where code execution does not pan out, a request that arrives looking like it came from 127.0.0.1 walks past every IP allowlist the application enforces.
Which front ends reuse FastCGI connections?
The advisory names the paths that matter. In nginx it is fastcgi_keep_conn on. In Apache's mod_proxy_fcgi it is enablereuse=on on the proxy worker. HAProxy deployments that retain backend connections are also listed. Both nginx and Apache leave reuse off unless someone enables it, which is why PHP.net's pre-release notice said its critical issues need non-default or uncommon setups. The catch is that connection reuse is a common performance tweak, and tuning guides recommend it.
LiteSpeed users get a narrower warning. The advisory says the same cleanup error affects LiteSpeed's LSAPI interface and can disrupt later requests, but it does not establish code execution through LSAPI. Treat LiteSpeed servers as needing the upgrade, with less urgency than an nginx box running keepalive to FPM.
If you upgraded for the October PHP release that fixed CVE-2026-109618, that work does not cover this bug. Those builds, 8.5.12, 8.4.27, 8.3.36 and 8.2.35, are exactly the last vulnerable ones here.
Check your front end and PHP build before anything else
The block below is read-only. It looks for connection reuse in the usual nginx and Apache config trees, prints the PHP and PHP-FPM versions, and checks whether session upload progress is switched on for the second bug. Binary names vary by distribution (for example php-fpm8.3 on Debian and Ubuntu), and control-panel stacks often keep PHP under /opt, so widen the paths to match your layout.
grep -rnE 'fastcgi_keep_conn|enablereuse' /etc/nginx /etc/httpd /etc/apache2 2>/dev/null php -v php-fpm -v grep -rn 'session.upload_progress.enabled' /etc/php* /etc/opt 2>/dev/null # fixed: 8.5.13, 8.4.28, 8.3.37, 8.2.36
A hit on fastcgi_keep_conn on or enablereuse=on on a server running an unpatched build is the combination to fix first. No hit, and the smuggling path described in the advisory is closed on that host, though upgrading is still the right move.
Patch now, or turn off FastCGI reuse until you can
The fix is the new PHP release for your branch. If your PHP comes from a distribution or a hosting control panel rather than php.net, the version number you see may not move, because vendors backport fixes. Check the package changelog for the CVE ID instead. As of its bulletin RHSB-2026-020, Red Hat lists RHEL 7 through 10 as affected, says it is expediting fixes, and had not yet published fixed packages.
Until the patched package lands, disable connection reuse: set fastcgi_keep_conn off (or delete the line) in nginx, and remove enablereuse=on from Apache's FastCGI proxy settings, then reload. Both PHP and Red Hat give that as the interim mitigation. The advisory adds a warning worth repeating: making your own code read php://input to the end is not a reliable fix on its own, because you rarely control every script on a server.
The cost is a little latency from opening a fresh connection per request. On most sites that is invisible, and it is a fair price for closing a critical bug while you wait on a vendor.
The second critical fix: CVE-2026-115560 in PHP sessions
The same release fixed CVE-2026-115560, also rated 9.2 by the PHP project, in the session extension. Per its advisory, the session upload progress feature can write session data in one serializer format while a reader using a different format hands part of an attacker-supplied key to unserialize(). Turning that into code execution needs a usable object gadget chain in the application, and the reporters cite usable gadgets in Guzzle and Monolog, two widely used PHP libraries. The libraries are not themselves vulnerable, but their classes can be abused once unserialize() receives attacker input.
The two sources disagree on preconditions. Aikido describes exposure as code switching serializers at runtime with ini_set(). The PHP advisory says no runtime change is required, and that a mismatch can also come from separate applications, pools or virtual hosts sharing one session store with different fixed settings. Shared hosting with a common session directory fits that second description, so we would plan around the broader reading. Red Hat's interim mitigation is to set session.upload_progress.enabled=0 in the server configuration, where the application cannot override it. The fixed releases also turn upload progress off by default.
Exploitation status and the GitHub toolkit
CISA's assessment attached to the CVE record on 20 November marks exploitation as none, automatable as yes, and technical impact as total. Aikido reported no in-the-wild exploitation either. On 21 November a GitHub repository appeared claiming to be an exploitation toolkit for CVE-2026-129289, with reverse shell and webshell modes. It had no stars and an unknown author, and we have not verified that it works. Do not run tools like that on infrastructure you care about. Their appearance does shorten the window: smuggling bugs that need only a crafted request tend to get scanned for soon after a working exploit is confirmed.
This is the third critical bug in the web-serving layer we have covered in November, after the Apache HTTP/2 race and the nginx HTTP/2 flaw. This one differs in a useful way: the version number alone does not tell you whether you are exposed, a proxy setting does. Operators who track only package versions will misjudge it in both directions. If that inventory is the hard part, our vulnerability detection page explains how we approach it.