- PHP's November 19 release fixes 17 new CVEs in the runtime, seven rated Critical by PHP, plus a separate bundled-library flaw, according to Semgrep.
- Exposure depends on configuration, such as session upload progress or PHP-FPM connection reuse, so a version number alone does not settle the question.
- Inventory your PHP deployments, upgrade to 8.2.36, 8.3.37, 8.4.28, 8.5.13 or 8.6.0, and treat temporary mitigations as a stopgap.
A clean application can still sit on a flawed foundation
Most security effort goes into the code a company's own developers write. PHP's November 19 release is a reminder that the layer underneath can fail too. Semgrep, the code-security vendor that reviewed the release, puts it this way: "an application can be secure while the environment executing it is not."
Semgrep counts 17 new CVEs in this release. The flaws sit in several areas: the engine itself, how sessions are stored, how time zones are handled, and PHP-FPM. PHP rates seven as Critical, each scoring 9.2 on the CVSS v4 scale.
The release also updates uriparser, a library bundled with PHP. That fix covers a separate flaw, CVE-2026-48841. Teams on the 8.2 line should move to 8.2.36. Those on 8.3, 8.4 and 8.5 need 8.3.37, 8.4.28 and 8.5.13. PHP 8.6.0 carries the fixes too.
The lesson here is about ownership. Application teams own their code. In many organisations the runtime may belong to a different team, and the two groups may not talk. That is our reading, not something Semgrep reports. If it holds, a runtime flaw can sit unclaimed between them.
How two of the flaws work
Semgrep highlights two flaws that give attackers a clear route to remote code execution. The first is CVE-2026-115560, a session serializer mismatch. A serializer turns data into stored bytes and back again.
Here is the trap. If upload progress tracking is on, an attacker can shape session data saved in the php_binary or php_serialize format. If PHP later reads that session in the php format, it may treat those bytes as serialized objects.
Running code then needs a "gadget chain". That is existing code in the reading application that can be strung together to do harm. Without one, Semgrep says the result can still be damaged sessions, altered files or a crash.
The final advisory adds a point for larger estates. The two formats can meet when separate applications, pools or processes share one session store.
The second flaw is CVE-2026-129289, in PHP-FPM. This is the component that runs PHP code behind a web server. Leftover request bytes can be misread as a second, hidden request.
That needs two things. PHP-FPM must reuse its backend connections, and an application must open php://input without reading all of it. If both hold, an attacker may skip the front-end routing and run PHP code as the worker. Semgrep notes it needs no memory corruption. It does rely on those conditions.
Exposure depends on configuration, not only on version
Semgrep's table attaches conditions to nearly every entry. The PHP-FPM flaw needs persistent connections to the backend, set through options such as fastcgi_keep_conn or enablereuse. Common nginx and Apache setups close that connection after every request. Semgrep says the demonstrated attack does not work against them.
Other entries are narrower still. One php-cgi flaw needs the cgi.fix_pathinfo=1 setting plus inconsistent path mappings. Semgrep's table lists servers running PHP-FPM or mod_php as unaffected by that flaw. A privilege-escalation flaw first needs code already running inside an FPM worker.
Semgrep's practical point is simple. Finding a vulnerable PHP install is one task. Judging whether an attacker can use it is another. The runtime, the web server settings and the application's code paths all shape the answer.
A flaw that waited
Semgrep also passes on the PHP Foundation's account of an older out-of-memory problem. Semgrep's account appears to concern the earlier PHP2Shell flaws, CVE-2026-109618 and CVE-2026-109619, which PHP patched on October 21, rather than the 17 new CVEs. The source does not name the CVE.
According to the Foundation, an outside security audit spotted the weakness in 2024. Researchers suspected it could be exploited but had no working attack. The fix stalled. Developers struggled to balance the fix against older software still working, speed, and the chance of breaking add-ons from other parties.
In August 2026, researchers at Calif showed code execution through the flaw. Semgrep credits the Foundation with being candid. The Foundation said limited resources and its decision-making processes played a part in the delay.
That is one project's account, not a pattern. It still shows how a known weakness can wait while people weigh trade-offs. For buyers, the practical step is to ask each vendor how it tracks known-but-unexploited weaknesses and how quickly it tells customers when one becomes exploitable.
Semgrep also says PHP issued a notice on October 23. It suggested session.upload_progress.enabled=0 as a stopgap for CVE-2026-115560. Every PHP worker must restart for it to apply. Semgrep says it narrowed that one attack path but was no substitute for upgrading.
What leaders should ask their teams
Semgrep sells security tooling. Its own workflow produces candidates to review, not confirmed exposure. Its advice on process holds up without the product.
First, where does PHP run in our organisation, and on which versions? Semgrep warns that the runtime an application will use is not always easy to pin down.
Second, which internet-facing systems use mod_php, PHP-FPM or CGI? Semgrep says to start there.
Third, do any PHP-FPM setups reuse backend connections? Do any application paths open php://input and leave it unread? Fourth, is session upload progress on anywhere that shares session storage?
Fifth, do we run PHP versions that no longer get fixes? Semgrep advises asking vendors for security backports or moving to a supported release. It also says to install the latest security release, because more updates followed the October patches.
A secure application on an unknown runtime is only half an answer. Knowing what you run, and where it faces the network, decides how fast you can respond.
Produced by the WebPulse Newsroom with AI assistance from the original reporting credited below, and checked against that source by our editorial review. How we use AI.
Original reporting: Semgrep.





