PHP has published new security updates following the two runtime RCEs covered in our earlier PHP2Shell report, which analyzed CVE-2026-109618 and CVE-2026-109619.
The November 19, 2026 release addresses 17 new PHP CVEs. Seven are rated Critical by PHP, each with a CVSS v4 score of 9.2:
The issues affect core runtime behavior, session handling, timezone processing, and PHP-FPM. PHP also updated the bundled uriparser library for CVE-2026-48841, a separate dependency vulnerability. The fixes are included in PHP 8.2.36, 8.3.37, 8.4.28, 8.5.13, and PHP 8.6.0. (PHP release archive, PHP changelog)
These are runtime vulnerabilities, not flaws in a particular CMS or application. A well-written application can still be exposed if it runs on an affected PHP build, so organizations should identify their PHP deployments, review their SAPI and configuration, and upgrade promptly.
Understanding the Vulnerabilities
PHP’s November 19 security release addresses 17 PHP CVEs across the runtime and its extensions, plus a separate uriparser dependency issue. Seven PHP-native CVEs are rated Critical, with two standing out because they provide clear remote code execution paths.
CVE-2026-115560: session serializer mismatch. When session upload progress is enabled, an attacker can influence session data written with the php_binary or php_serialize format. If the same session is later read using the php serializer, PHP may interpret bytes from the session data as serialized objects. Remote code execution requires a suitable deserialization gadget chain in the reading application; otherwise, the issue can cause session corruption, file modification, or denial of service.
CVE-2026-129289: PHP-FPM request smuggling. When PHP-FPM reuses backend connections and an application opens php://input without fully consuming it, leftover request data can be interpreted as a second FastCGI request. An attacker may then bypass front-end routing and execute PHP code as the worker. This issue does not require memory corruption, but it does depend on persistent backend connections and application behavior.
Why the October 23 notice matters
PHP had already issued an informational notice on October 23, ahead of the November 19 release, recommending session.upload_progress.enabled=0 as a temporary safeguard for CVE-2026-115560. The notice described an attack path involving php_binary or php_serialize, a runtime switch to the php serializer, and enabled upload progress. The final advisory also notes that mismatched serializers can arise between separate applications, pools, or processes sharing session storage. Apply the setting in php.ini, the FPM pool configuration, or server configuration before request parsing, then restart every PHP worker so the setting takes effect. It reduced exposure to this specific attack path, but it was not a replacement for upgrading to PHP 8.2.36, 8.3.37, 8.4.28, 8.5.13, or PHP 8.6.0 where applicable. (PHP notice, CVE advisory)
The table below covers all 18 security entries: 17 PHP CVEs and the separate uriparser dependency issue, CVE-2026-48841. The full PHP changelog records the fixes and affected components. (PHP changelog)
CVE | Severity | Component | impact | Key exposure condition |
|---|---|---|---|---|
Critical 9.2 | Session | Serializer mismatch can cause attacker-influenced objects to be deserialized; with a suitable gadget chain, this can lead to RCE. | Upload progress enabled; a php_binary/php_serialize writer and php reader access the same session ID and session store. | |
Critical 9.2 | Session | Interrupted replacement writes can leave mixed session data; with a suitable object gadget chain, this can enable RCE. | Default | |
Critical 9.2 | Session | Interrupted session cleanup can leave a stale pointer and trigger a heap use-after-free; code execution through this specific field has not been demonstrated. | Fatal error in a session-cleanup callback followed by reuse of the same worker; PHP 8.3+. | |
Critical 9.2 | Core | Use-after-free in magic-method backtraces; RCE was demonstrated on affected PHP 8.5 versions under the reported configuration. | PHP 8.5 before 8.5.13; fatal error during call()/callStatic() with fatal_error_backtraces=1 and zend.exception_ignore_args=0. | |
Critical 9.2 | Core | Fatal diagnostics can repopulate a stale backtrace global; RCE through these specific entry points was not demonstrated. | PHP 8.5; max_memory_limit or zlib/output-handler conflicts, plus an early diagnostic in a later request. | |
Critical 9.2 | Date | Stale timezone cache can cause memory corruption, worker crashes, and potentially RCE. | File-based PHP error logging, startup and early-request diagnostics, a fresh or recycled worker, and an affected non-thread-safe build. | |
Critical 9.2 | PHP-FPM | Unread body bytes can become a second FastCGI request, enabling RCE. | Persistent FastCGI backend reuse, such as fastcgi_keep_conn or enablereuse, plus an application path that leaves php://input unread. Standard nginx/Apache configurations that close the backend connection after each request are not affected by the demonstrated path. | |
High 8.8 | PHP-FPM | epoll use-after-free can enable privilege escalation from an unprivileged FPM worker. | Local PHP execution in an FPM worker, the epoll backend, and catch_workers_output=on; root escalation requires an FPM master running as root. | |
High 8.7 | Standard streams | Folded HTTP headers can cause excessive CPU consumption and DoS. | Application fetches attacker-controlled HTTP responses. | |
High 8.2 | Standard streams | Mixed-case HTTPS/FTPS URLs can bypass TLS and expose data. | Mixed-case URLs reach stream wrappers, including redirects. | |
High 7.7 | Phar | OpenSSL-signed Phar archives can be downgraded and modified. | Archive altered while the trusted | |
Moderate 6.9 | CGI | PATH_INFO correction can cause out-of-bounds reads or writes, potentially resulting in a crash, disclosure, or memory corruption. | php-cgi in CGI/FastCGI mode, cgi.fix_pathinfo=1, and inconsistent path mappings; PHP-FPM and mod_php are not affected. | |
Moderate 6.3 | DOM | Namespace ownership bug causes double-free/use-after-free. |
| |
Moderate 6.3 | SOAP | Malformed | Crafted SOAP data reaches an affected endpoint. | |
Moderate 6.3 | SOAP | DTD entity references can access freed memory and crash PHP. | Attacker-controlled SOAP XML, WSDL, or schema is parsed. | |
Moderate 6.3 | URI | Oversized Uri\Rfc3986\Uri values can serialize incorrectly, exhaust memory, or terminate PHP. | PHP 8.5.0–8.5.12 URI input near the ~2 GiB boundary; fixed in 8.5.13. Legacy parse_url() and Uri\WhatWg\Url are not affected. | |
Moderate 5.3 | PHP-FPM | Unescaped status fields enable stored XSS in the HTML status page. | An attacker can poison scoreboard fields through a normal request; an operator must later view the full HTML status page. | |
Unrated by PHP; Nessus CVSS v3.0 9.8* | uriparser dependency | Integer overflow in | PHP builds with the URI extension and vulnerable bundled uriparser (<1.0.3). |
* Tenable/Nessus reports CVSS v3.0 9.8 for the affected FreeBSD uriparser package. PHP’s own advisory materials do not assign a CVSS score to CVE-2026-48841.
When the Runtime Becomes the Attack Surface
Application security traditionally focuses on vulnerabilities developers introduce into their code, such as SQL injection, insecure deserialization, and authentication failures. Those remain serious problems, but these PHP vulnerabilities illustrate another reality: an application can be secure while the environment executing it is not.
This doesn't make application security testing irrelevant. It means organizations need visibility across their entire software stack, including application code, third-party dependencies, runtime versions, and infrastructure.
There's also an important distinction between identifying a vulnerable PHP installation and determining whether an attacker can exploit it. The runtime, web server configuration, and available application code paths all influence exposure. Security teams need to understand both.
A Vulnerability Two Years in the Making
Perhaps the most interesting part of this disclosure is the story behind it. According to the PHP Foundation, the underlying out-of-memory issue was first identified in 2024 following an external security audit. Researchers suspected it might be exploitable but hadn't demonstrated a working attack. The issue remained unresolved as developers struggled to balance security fixes against backward compatibility, performance, and the risk of breaking third-party extensions.
In August 2026, researchers at Calif demonstrated remote code execution using the underlying flaw. Additional research from other researchers helped establish the severity and accelerate remediation.
To its credit, the PHP Foundation has been unusually transparent about the delays, acknowledging that limited resources and decision-making processes contributed to the problem. It has since expanded its security efforts, including adopting AI-assisted vulnerability research and validation.
What PHP Users Should Do Now
The PHP security team released patches for all supported branches on October 21. Additional security updates have since been published, so organizations should install the latest available security release rather than stopping at the original patches.
PHP branch | November 19 release |
PHP 8.6 | 8.6.0 |
PHP 8.5 | 8.5.13 |
PHP 8.4 | 8.4.28 |
PHP 8.3 | 8.3.37 |
PHP 8.2 | 8.2.36 |
All releases are available through the official PHP downloads page.
Organizations should prioritize internet-facing PHP deployments across mod_php, PHP-FPM, and CGI. For this release, review PHP-FPM backend connection reuse and application paths that open php://input; mod_php was especially relevant to the earlier PHP2Shell issues. For systems that cannot be updated immediately, the official PHP security announcement provides temporary mitigations. These may reduce exposure but are not substitutes for patching.
Organizations running unsupported PHP versions should investigate vendor-provided security backports or migrate to a supported release.
What Semgrep Users Can Do
First, upgrade affected PHP deployments to the fixed release for their branch: PHP 8.5.13, 8.4.28, 8.3.37, or 8.2.36. The official PHP release archive lists these November 19 security releases. If an immediate upgrade is not possible, apply the official temporary mitigations as a short-term measure; they do not replace patching. Semgrep can then help identify candidate projects for prioritization and review, but it cannot confirm runtime exposure by itself.
Customers can run the updated Detect-2Shell agentic workflow to look more deeply at projects that may deploy versions of PHP. It produces candidates to review, not confirmed exposure based on source code configurations.
To identify projects that use PHP: as discussed above, it’s not always easy to pin down the runtime your code will execute with. If you’re looking for a list of projects that use PHP to inform your triage, use this script to quickly identify projects to review. We also created an experimental script that can help identify known usages of PHP for the CVEs above.
Security Doesn't Stop at Your Code
These vulnerabilities remind us that secure application code is only part of the equation. Developers can follow every recommended coding practice and still be exposed by vulnerabilities in the underlying runtime.
The answer isn't another security dashboard. It's understanding what software you're running, where it's exposed, and how quickly you can respond when something underneath your application breaks.
The PHP Foundation deserves credit for its transparency and investment in stronger security processes. But organizations running PHP shouldn't wait for the next disclosure to figure out where their PHP installations are hiding.
Knowing what you're running is the first step. Keeping it patched is the next.