Critical PHP RCE Flaw Highlights Risks in Session Upload Progress Handling
CVE-2026-115560 is a critical PHP session handling vulnerability that could allow remote code execution through deserialization confusion. Explore the root cause, affected configurations, exploitation risks, and recommended mitigations.
Summary
A critical remote code execution (RCE) vulnerability, tracked as CVE-2026-115560, has been identified in PHP's session handling mechanism. The vulnerability arises from inconsistent session serialization behavior when applications dynamically switch serialization handlers while PHP's session upload progress feature is enabled.
Although exploitation requires an uncommon combination of configuration settings and application code, a vulnerable deployment could allow an unauthenticated attacker to inject malicious serialized objects and potentially execute arbitrary code on the affected server.
The PHP security team disclosed the issue on October 23, 2026, and scheduled its remediation for the regular security release cycle on November 19, 2026. Until the corresponding security updates are installed, administrators are advised to disable session upload progress in affected environments.
Vulnerability Details
| CVE ID | Severity | Affected Product | Vulnerability Type |
|---|---|---|---|
| CVE-2026-115560 | 9.8 (Critical) | PHP applications using the affected session serialization configuration | Deserialization Confusion / PHP Object Injection / Remote Code Execution |
Affected Deployment Environments: Potentially affected configurations may occur in PHP-FPM, Apache with mod_php, php-cgi, FrankenPHP, and LiteSpeed environments. Exposure depends on application behavior and session settings, not merely the web server integration.
The vulnerability requires all of the following conditions:
- • The application initially configures
session.serialize_handlerasphp_binaryorphp_serialize. - • The application dynamically changes the session serializer to
phpusingini_set(). - • The change occurs before the application calls
session_start(). - • The
session.upload_progress.enabledconfiguration remains enabled. - • An attacker can influence data processed through the affected session upload mechanism.
The PHP security team has emphasized that applications which never dynamically change the session serialization handler are not exposed to this specific issue.
Attack Methodology
Phase 1: Identification of a Vulnerable PHP Application
An attacker would first need to identify a PHP application using the unusual combination of session serialization settings required for CVE-2026-115560.
The vulnerable configuration must begin with php_binary or php_serialize and later switch to php at runtime before the session is initialized.
Since these settings are controlled by application code and server configuration, identifying an exploitable deployment is more difficult than targeting a vulnerability present in all default PHP installations.
Phase 2: Manipulation of Session Upload Progress Data
Once a vulnerable application is identified, an attacker could submit a specially crafted multipart HTTP request that interacts with PHP's session upload progress feature.
When session.upload_progress.enabled is active, PHP may write upload-related data into the session file before the application completes its normal session initialization.
In the affected configuration, this data is initially stored using the serialization format configured at the beginning of request processing.
This creates an opportunity for attacker-influenced data to be introduced into the session storage mechanism before the application changes its serialization settings.
Phase 3: Runtime Session Serialization Handler Change
During request processing, the vulnerable application changes its session serialization handler to php using ini_set().
The application then calls session_start(), causing PHP to read the existing session data using the newly configured serialization format.
However, the stored data may have been written using the earlier php_binary or php_serialize format.
Because the serialization formats differ, PHP may interpret the session contents incorrectly.
Phase 4: Deserialization Confusion and Object Injection
The root cause of CVE-2026-115560 is the inconsistent interpretation of session data across different serialization handlers.
The php serialization handler uses the pipe character (|) to separate session variable names from serialized values. Other handlers represent session data differently.
When session content written using one format is parsed using another, attacker-influenced bytes may be misinterpreted as serialized PHP objects.
This can enable PHP object injection, in which an attacker influences the creation of objects or the restoration of object properties during deserialization.
The impact depends on the application's available classes and how those classes handle object lifecycle operations.
Phase 5: Potential Remote Code Execution
If the affected application contains suitable object gadget chains, malicious serialized objects may trigger unintended application behavior during deserialization.
Such behavior may include file operations, unauthorized application actions, or command execution.
When a usable execution chain exists, an unauthenticated attacker may be able to achieve remote code execution within the security context of the PHP application.
This outcome is conditional and does not occur automatically in every PHP application using session upload progress.
MITRE ATT&CK Techniques
The following MITRE ATT&CK tactics and techniques describe behaviors that may be associated with successful exploitation.
| Technique ID | Technique / Tactic | Description |
|---|---|---|
| T1190 | Exploit Public-Facing Application | Potential exploitation of a vulnerable internet-facing PHP application. |
| T1059 | Command and Scripting Interpreter | Potential execution of attacker-controlled commands through the affected application. |
| T1210 | Exploitation of Remote Services | Potential follow-on exploitation of accessible services after initial compromise. |
Mitigation
Organizations running PHP applications should prioritize the following measures to reduce exposure to CVE-2026-115560:
- • Apply PHP Security Updates: Install the applicable vendor security releases containing the fix for CVE-2026-115560 as soon as they are available, and verify the installed PHP runtime version.
- • Disable Session Upload Progress: Set
session.upload_progress.enabled=0in an administrator-controlled PHP configuration file, such asphp.ini, or the appropriate server or PHP-FPM configuration. - • Avoid Runtime-Only Mitigation: Do not rely on
ini_set()or per-directory.user.inisettings for this mitigation, because upload progress is processed before normal application execution. - • Restart PHP Workers: Restart the affected PHP worker processes after modifying the configuration and verify that the setting is active in the web-serving PHP environment.
- • Review Session Configuration: Audit application code for dynamic changes to
session.serialize_handler, especially changes tophpbefore callingsession_start(). - • Monitor Application Activity: Investigate suspicious multipart uploads, malformed session data, unexpected process execution, and unauthorized file modifications.
- • Confirm Previous PHP2Shell Patches: Ensure the October 2026 PHP2Shell security fixes remain deployed, as those vulnerabilities are separate from CVE-2026-115560.
Instantly Fix Risks in Endpoints & Cloud with Saner
Saner is a continuous and integrated vulnerability & exposure management platform that instantly fixes risks in endpoints and cloud.




