Meta description: PHP 8.5.13, 8.4.28, 8.3.37 and 8.2.36 fix seven critical vulnerabilities. Here is what each one does, what fixed it, and how to confirm you're covered.
If you run PHP, update today. The PHP team shipped security releases on November 19, 2026: 8.5.13, 8.4.28, 8.3.37, and 8.2.36. PHP 8.6.0 launched the same day and includes the fixes too.
The release covers 17 vulnerabilities in total: 7 critical, 4 high, and 6 medium. All seven critical ones score 9.2 on CVSS 4.0, which is why this is getting attention. The good news is that none of the seven is listed in CISA's Known Exploited Vulnerabilities catalog, and as of today nobody has reported them being exploited in the wild. Nearly all of them also need a specific setup to be reachable. PHP's own advance notice said the critical issues depend on non-default configurations or uncommon setups.
Still, "needs a specific setup" is a weak shield when you run a lot of servers. Here's what was broken and what changed.
Why this feels familiar
This is the second major PHP security release in about a month. On October 21 the team shipped emergency fixes for two critical bugs, CVE-2026-109618 and CVE-2026-109619, nicknamed PHP2Shell. Two days later PHP published an informational note about a third, related session issue (CVE-2026-115560) and told people to turn off a feature called session upload progress until a proper fix landed.
Today's release is that proper fix, plus several more bugs that turned up while people looked closely at the same area. Researchers kept pulling on the thread, and the PHP team kept patching. That's how it's supposed to work, even if it's a lot of upgrades in a short time.
The seven critical issues
| CVE | Where | What it is | Affected |
|---|---|---|---|
| CVE-2026-129289 | PHP-FPM | Request smuggling | 8.2 to 8.5 |
| CVE-2026-115560 | Sessions | Unsafe deserialization | 8.2 to 8.5 |
| CVE-2026-126714 | Sessions | Unsafe deserialization | 8.2 to 8.5 |
| CVE-2026-129496 | Date extension | Use-after-free | 8.2 to 8.5 |
| CVE-2026-129481 | Sessions | Use-after-free | 8.3 to 8.5 |
| CVE-2026-129182 | Engine | Use-after-free | 8.5 only |
| CVE-2026-129474 | Engine | Use-after-free | 8.5 only |
Two terms show up a lot, so quick definitions. A use-after-free happens when code keeps using a piece of memory after it was handed back to the system. The old data may be garbage by then, or attacker controlled, and that can mean crashes or code execution. Unsafe deserialization happens when PHP turns stored text back into objects using unserialize(). If an attacker controls that text, they can build objects that run code, usually by chaining together classes that already exist in your vendor folder (these chains are called gadgets).
1. PHP-FPM request smuggling (CVE-2026-129289)
This one stood out in the write-ups. When a front end like nginx reuses its connection to PHP-FPM, a request body that your code opens through php://input but doesn't fully read could leave leftover bytes on the connection. PHP treated opening the stream as proof that the body had been dealt with, so it skipped the cleanup. An attacker can craft a malformed multipart body so those leftover bytes look like a second, forged FastCGI request, one that can set things like SCRIPT_FILENAME and PHP_ADMIN_VALUE. That can end in attacker-controlled PHP running in your worker.
You're only exposed if the connection is being reused: nginx with fastcgi_keep_conn on, or Apache's FastCGI proxy with enablereuse=on. Standard setups that close the connection after each request aren't affected by the demonstrated attack. The underlying behavior goes back to PHP 5.6.0, so it has been sitting there a while. LiteSpeed's LSAPI shares the same cleanup mistake and can get its request stream out of sync, but nobody has shown code execution through it.
The fix makes PHP clean up leftover request bytes properly before it reuses a connection.
2. Session upload progress (CVE-2026-115560)
This is the third PHP2Shell bug. Session upload progress is an old feature that lets an upload progress bar read its status from the session. It has been on by default since PHP 5.4. An unauthenticated request can use it to write attacker-chosen bytes into the session store.
That alone isn't fatal. The problem shows up when two parts of a deployment disagree about the session format. One writes with the php_serialize or php_binary handler, and another reads with the default php handler. The php reader splits each record at the first pipe character and passes the rest to unserialize(). A pipe inside the attacker's data turns into object injection. Researchers demonstrated code execution with gadget chains from Guzzle and Monolog.
Separate FPM pools or virtual hosts sharing one session store can hit this, because separate pools don't automatically get separate session storage.
The fix does two things. Upload progress is now off by default, and PHP rejects runtime changes to session settings (including session.serialize_handler) while upload progress is on.
There's a catch. If any php.ini, pool, or vhost explicitly sets session.upload_progress.enabled = On, that overrides the new default. PHP also doesn't compare configurations across contexts, so a mismatch between two apps is still your job to check.
3. Interrupted session writes (CVE-2026-126714)
This affects the default files session handler, even with upload progress off. If a session write gets interrupted, old session data can be exposed in a way that PHP reads back as objects. Exploiting it takes three things: an interrupted write, an attacker with influence over what's in the session, and a usable gadget chain. If your app stores user input in $_SESSION, this is the one to think about.
4. Four use-after-free bugs
The last four are memory bugs.
Date extension (CVE-2026-129496). Security researcher Sebastian Bergmann wrote up how he found this one. If PHP logs a warning during startup, such as a bad date.timezone value or a deprecated session setting, it creates a timezone cache in memory that gets released at the end of startup. Nothing resets the pointer to it. The first request on a fresh worker then reads freed memory. A crafted request can crash fresh php-fpm and mod_php workers, and the PHP team showed local code execution under extra conditions. It only applies when startup warnings go to a file-based error log.
Session shutdown (CVE-2026-129481). A fatal error in a callback during session cleanup leaves a stale pointer behind. It's described as an incomplete fix for the October bug CVE-2026-109619. Code execution hasn't been demonstrated.
Engine, PHP 8.5 only (CVE-2026-129182 and CVE-2026-129474). Both involve fatal-error backtraces, a feature that is on by default in 8.5. One lets a stale backtrace carry over into the next request. The other can corrupt memory when a fatal error happens inside __call() or __callStatic(), through the arguments captured in the backtrace. The second one has a confirmed code execution chain, though it needs known memory addresses. PHP's recommended php.ini-production already sets zend.exception_ignore_args=1, which blocks that second path.
The fixes make sure these pointers are reset or cleaned up before the next request can touch them.
A high-severity bug worth a look
One more fix deserves a mention even though it isn't critical. CVE-2026-129291 affects the PHP-FPM master process. Someone who can already run PHP in a worker, such as a customer on a shared host, could run commands with the master's privileges, which are often root. It needs the epoll event backend and a pool with catch_workers_output enabled. If you can't update yet, turn that setting off.
PHP 8.5.13 also updates the bundled uriparser library to address CVE-2026-48841.
How to make sure you're covered
Upgrading is the only step that covers all seven. Here's a short checklist.
-
Update to a fixed version. That's 8.2.36, 8.3.37, 8.4.28, or 8.5.13. Package managers may ship fixes as backports with an older-looking version number, so check your vendor's security tracker if the numbers don't match.
-
Restart everything. FPM masters, workers, and any long-running processes need a restart to pick up the new build.
-
Check the web side, not just the CLI. FPM pools and the command line can load different PHP builds and different configs. Confirm what your web server actually runs:
<?php // Temporary check. Delete it after you've looked. echo PHP_VERSION, ' (', PHP_SAPI, ')';From a shell,
php-fpm -vtells you what your FPM binary is. -
Rebuild containers. Images that bundle their own PHP don't update themselves. One example from the write-ups is the wodby/nginx image, which hard-codes
fastcgi_keep_conn on. -
Audit session settings. Search for explicit
session.upload_progress.enabledvalues, and make sure every app sharing a session store uses the samesession.serialize_handler.
If you truly can't upgrade today, these stopgaps reduce your exposure:
; php.ini or your FPM pool config (not ini_set())
session.upload_progress.enabled = 0
zend.exception_ignore_args = On
; PHP 8.5 only
fatal_error_backtraces = 0
On the front end, keep nginx's fastcgi_keep_conn off or Apache's enablereuse off so the connection closes after every request. Also fix any startup warnings in your PHP logs, then restart. Treat all of this as a bridge, though. None of these settings replaces the update.
What about old PHP versions?
PHP 8.1 and older don't get upstream fixes, and PHP says older unsupported releases may also be affected by the session bug. Researchers reproduced the session issue on versions as old as 5.4. If you're stuck on one, set session.upload_progress.enabled = 0 in php.ini, not in application code. Plesk has said it plans to backport fixes to PHP 8.1, 8.0, and 7.4 on Linux, and other vendors may do the same. Treat that as a way to buy time. PHP 8.2 reaches end of life on December 31, 2026, so this is a good moment to plan your move.
One more thing
The date bug has a nice story behind it. After the October PHP2Shell fixes, Sebastian Bergmann (the PHPUnit author) wrote down a simple rule: once a request ends, no global variable that outlives it should point at memory the request released. He then checked for violations of that rule, and a crash in an unexpected place led him to the timezone cache. His post on how he found it is worth your time, especially the point that single-request tests can't catch bugs that only appear when the next request reuses leftover state.
PHP's security process isn't glamorous, but it's working: researchers dig, the team triages quickly, and fixes land across every supported branch on the same day. Your part is the boring one. Update, restart, and check.
References
- The Hacker News, "PHP Fixes 7 Critical Flaws" (Nov 19, 2026): https://thehackernews.com/2026/11/php-fixes-7-critical-flaws-including.html
- Webhosting Today, "PHP patches 7 critical flaws a month after PHP2Shell" (Nov 19, 2026): https://webhosting.today/2026/11/19/php-patches-7-critical-flaws-a-month-after-php2shell/
- Upwind, "PHP critical vulnerabilities: affected versions and mitigations": https://www.upwind.io/blog/php-critical-vulnerabilities-affected-versions-and-mitigations
- Zest Security, "PHP2Shell: the third one (CVE-2026-115560)": https://www.zestsecurity.io/resources/content/php2shell-the-third-one-cve-2026-115560
- Sebastian Bergmann, "The wrong crash," phpunit.expert: https://phpunit.expert/articles/the-wrong-crash.html
- php-src security advisory GHSA-qc49-hpvq-g2w6, "PHP-FPM request smuggling through an unread HTTP request body" (CVE-2026-129289): https://github.com/php/php-src/security/advisories/GHSA-qc49-hpvq-g2w6
- PHP.net news archive, 2026 (release announcements for 8.2.36, 8.3.37, 8.4.28, 8.5.13, 8.6.0 and the Nov 18 advance notice): https://www.php.net/archive/2026.php
- BleepingComputer, "PHP ships emergency patches for critical PHP2Shell flaws" (Oct 21, 2026): https://bleepingcomputer.com/news/security/php-ships-emergency-patches-for-critical-php2shell-flaws
- Computing, "PHP discovers new remote code execution flaw but rules out emergency fix": https://www.computing.co.uk/news/2026/security/php-finds-new-remote-code-flaw-no-fix