Maintainers of the PHP runtime have issued coordinated security updates resolving a critical vulnerability tracked as CVE-2026-115560. Rated with a CVSS v4.0 base score of 9.2 (Critical), the flaw exists within PHP's core session handling subsystem, specifically involving a mismatch between different session serialization handlers when tracking file upload progress. Under vulnerable operational configurations, an unauthenticated remote attacker can inject controlled serialized data into a session key, potentially leading to arbitrary remote code execution, session corruption, or denial of service.

The issue affects multiple maintenance series of the PHP interpreter, requiring immediate assessment by enterprise infrastructure teams, shared hosting providers, and organizations running distributed PHP architectures where multiple applications or runtime contexts share a centralized session storage layer.

Technical Context and Root Cause Analysis

PHP provides native functionality to track the progress of file uploads in real time via the session.upload_progress.enabled configuration directive. When an upload request containing the specified progress key is received, PHP automatically stores tracking metrics—such as bytes received and content length—within the active session storage using a designated session key.

The architectural root cause of CVE-2026-115560 arises from format incompatibilities across PHP's built-in session serialization handlers:

  • php_serialize: Uses standard PHP serialization format equivalent to serialize() and unserialize().
  • php_binary: Encodes variable names using a single byte denoting string length, followed by the raw name and serialized value.
  • php: The default internal handler, which structures records using the variable name followed by a vertical bar delimiter (|) and the serialized payload.

When session upload progress is enabled, PHP can record attacker-controlled input within a session key while operating under the php_binary or php_serialize handler. If that same session dataset is subsequent to creation read by an application context configured to interpret data using the default php serializer—such as when session.serialize_handler is dynamically altered at runtime or differs across distinct microservices reading a shared Redis or Memcached session store—the parser logic breaks down.

Because the php handler relies on the pipe character delimiter to separate keys from values, specially formatted bytes embedded inside the upload progress key are misidentified as payload boundaries. Consequently, attacker-controlled raw bytes located inside the session key are forwarded directly into PHP's internal deserializer routine.

Attack Mechanics and Exploitation Requirements

The vector allows an unauthenticated remote attacker to submit a standard HTTP multipart form upload containing malicious structures embedded within the upload progress field. The vulnerability does not require prior authentication to the target web application, provided the upload endpoint is accessible and sessions are instantiated.

However, achieving full remote code execution depends on specific environmental prerequisites:

  • Serializer Discrepancy: The session must be written or populated using either php_binary or php_serialize, and subsequently evaluated by a runtime context running the php handler. This scenario commonly occurs in heterogeneous enterprise architectures, shared session backends (such as centralized Redis or database session clusters), or legacy environments where applications alter session.serialize_handler via ini_set().
  • Presence of Gadget Chains: For arbitrary code execution to occur, the reading application, its framework, or its imported vendor libraries must possess a usable "POP chain" (Property-Oriented Programming). When the deserializer parses the injected object, magic methods such as __destruct(), __wakeup(), or __toString() must trigger execution flow leading to code evaluation.
  • Alternative Impact: If a viable gadget chain is not present within the runtime scope, the injected payload can still trigger memory corruption within the session record, invalidate authenticated user states, or trigger unhandled exceptions leading to denial of service.

Affected Deployments and Version Matrix

The vulnerability spans all actively maintained PHP release branches prior to the security patch releases. Systems utilizing default monolithic configurations without serializer switches are less immediately exposed to object injection, but environments running shared cache nodes across varied codebases face substantial exposure.

PHP Branch Vulnerable Versions Remediated Release
PHP 8.2 Versions prior to 8.2.36 8.2.36
PHP 8.3 8.3.x prior to 8.3.37 8.3.37
PHP 8.4 8.4.x prior to 8.4.28 8.4.28
PHP 8.5 8.5.x prior to 8.5.13 8.5.13

Practical Remediation and Response

Engineering teams and system administrators should immediately execute the following defensive measures across production and staging environments:

1. Apply Upstream Binary and Package Updates

Deploy the updated PHP binaries corresponding to the deployed branch: upgrade to PHP 8.2.36, 8.3.37, 8.4.28, or 8.5.13. Container images, standard operating system repositories, and custom source builds should be updated and services restarted immediately to ensure runtime memory reflects the patched deserialization logic.

2. Standardize Session Configuration Directives

Audit php.ini and runtime configurations to eliminate handler divergence. Ensure that session.serialize_handler is explicitly defined and uniform across all applications that share a common session cluster:

session.serialize_handler = php_serialize

Ensure that individual codebases do not dynamically modify this setting at runtime using ini_set('session.serialize_handler', ...) while sharing storage buckets with other services.

3. Temporary Mitigation via Upload Progress Disablement

If binary patching cannot be performed immediately, organizations can mitigate the primary entry vector by disabling session upload progress tracking entirely in global configuration profiles:

session.upload_progress.enabled = Off

Disabling this directive stops the interpreter from parsing multipart upload progress keys and injecting arbitrary user-submitted keys into the session storage.

What Remains Unknown

As of publication, security tracking records show no evidence of active exploitation in the wild, and the vulnerability is not cataloged within the CISA Known Exploited Vulnerabilities (KEV) database. While the mechanics of the serializer mismatch are documented, the public availability of generic automated exploit tooling remains unconfirmed. Furthermore, the broader susceptibility of enterprise systems hinges heavily on undocumented application-specific gadget chains present within bespoke production dependencies.