PHP Readies Critical RCE Patch CVE-2026-115560 for File Uploads

PHP maintainers are releasing critical security updates to address CVE-2026-115560, an RCE flaw in file-upload progress tracking affecting non-default configurations.

TL;DR

  • What happened: PHP maintainers scheduled critical security updates for 19 November 2026 between 14:00 and 14:30 UTC to address CVE-2026-115560, a remote code execution defect in file-upload progress tracking.
  • Who is affected: Applications running all supported PHP versions where session.serialize_handler is configured to php_binary or php_serialize and then dynamically toggled to php at runtime via ini_set() prior to session_start().
  • Impact & Severity: Critical severity. Exploitation allows unauthenticated remote code execution by tricking PHP’s session parser into injected deserialization routines via upload progress variables.
  • Immediate action: Set session.upload_progress.enabled = Off in global configuration files as an immediate mitigation, audit application code for runtime INI modifications, and apply vendor updates upon release.

Engineering teams managing PHP environments face a critical maintenance window following the announcement of cve-2026-115560, a remote code execution vulnerability located in PHP’s core file-upload progress tracking subsystem. Scheduled for publication on 19 November 2026 between 14:00 and 14:30 UTC, the official patches address security vulnerabilities affecting all supported PHP release branches with a maximum severity rating of Critical. The disclosure comes exactly two days after the security community addressed the widespread impact of the PHP2Shell vulnerabilities (including CVE-2026-109619).

Unlike vulnerabilities affecting standard out-of-the-box defaults, triggering CVE-2026-115560 requires a specific alignment of configuration parameters and runtime code execution paths. Specifically, an environment must set the system-level session serialization handler to a non-standard value, modify that handler dynamically within application logic prior to initialising the session context, and maintain active session upload tracking.

While default PHP runtimes remain protected against this specific attack vector, legacy applications, enterprise frameworks with custom session abstractions, and shared hosting environments with per-directory INI overrides face distinct risks. Systems administrators and application security engineers must understand the underlying session deserialization mechanics, identify vulnerable code patterns across code repositories, and implement operational mitigations prior to upstream package deployment.

Anatomy of PHP CVE-2026-115560

The root cause of CVE-2026-115560 lies within the interaction between PHP’s request parsing engine, session state handling, and the file-upload progress tracking mechanism. Introduced to provide real-time telemetry for HTTP multipart upload requests without requiring external extensions, file upload progress tracking intercepts incoming multipart/form-data POST payloads before main script execution begins.

When PHP processes an HTTP upload request containing a field matching the configured session.upload_progress.name key (which defaults to PHP_SESSION_UPLOAD_PROGRESS), the engine automatically allocates a tracking array within the global $_SESSION structure. This data structure includes upload metrics such as total content length, current bytes received, upload start time, and individual file metadata. This initial structure creation occurs during request startup, using the globally defined session.serialize_handler configured in php.ini or the server pool setup.

Deserialization Boundary Mismatch

The flaw manifests when data written into the session store using one serialization handler format is subsequently read and parsed using a different handler format. Switching session handlers midway breaks field boundary validation in the session engine.

PHP natively supports three distinct session serialization handlers:

  • php: The legacy format. It uses a pipe character (|) as a delimiter separating variable names from their serialized values (for example, var_name|s:5:"value";).
  • php_serialize: The modern format. It encodes the entire $_SESSION array as a single serialized object using standard serialize() structures.
  • php_binary: A binary-encoded format that uses character length bytes instead of string delimiters to define variable key lengths.

The defect in CVE-2026-115560 occurs when the file-upload progress module writes session state using the structure enforced by php_serialize or php_binary, but the application runtime subsequently executes ini_set('session.serialize_handler', 'php') before invoking session_start(). When session_start() executes under the php handler, the deserialization engine scans the session file stream looking for pipe characters (|) to split keys and values.

PHP Request Execution Lifecycle (CVE-2026-115560 Attack Vector)

[ HTTP Multipart Request ] │ ▼ 1. Core Request Startup: - Reads global php.ini: session.serialize_handler = php_serialize - Detects PHP_SESSION_UPLOAD_PROGRESS field in POST payload - Writes upload metrics into session store using php_serialize engine │ ▼ 2. User Script Execution Begins: - Executing: ini_set('session.serialize_handler', 'php'); - Executing: session_start(); │ ▼ 3. Session Deserialization Failure: - Engine reads raw session file using legacy 'php' handler - Engine parses pipe '|' characters injected via upload metadata - Variable boundaries shift, causing arbitrary object injection │ ▼ [ Remote Code Execution / Unsafe Object Instantiation ]

Because the original data was serialised under a different format, the boundaries between array keys and values become misaligned. An attacker controlling the value of the upload progress key or form metadata can inject pipe characters and craft serialized payload strings. When the legacy php handler parses this stream, it misinterprets the injected pipe character as a variable name boundary, treating user-supplied string data as valid serialized objects, leading to arbitrary object injection and remote code execution.

PHP maintainers operate on a strict four-week release cycle. CVE-2026-115560 was publicly disclosed two days after the PHP2Shell vulnerabilities gained widespread industry attention. While technical details were provided regarding the triggering state conditions, public proof-of-concept exploit scripts and telemetry confirming active in-the-wild exploitation prior to official vendor patch availability have not been publicly disclosed.

Unusual Configuration Requirements and Attack Conditions

To evaluate corporate risk accurately, SREs and security engineers must note that CVE-2026-115560 cannot be exploited against standard, default PHP installations. Triggering the flaw requires a specific sequence of runtime operations and configuration directives.

Four primary prerequisites must exist simultaneously within the application environment for an endpoint to be exposed to exploitation:

  1. Global Non-Standard Handler: The global system configuration (set in php.ini, php-fpm.conf, or .htaccess) must set session.serialize_handler to either php_serialize or php_binary.
  2. Runtime Handler Switch: The application code must execute ini_set('session.serialize_handler', 'php') to reset the handler back to the legacy php mode during request execution.
  3. Precise Execution Ordering: The dynamic ini_set() call must execute before the script explicitly calls session_start().
  4. Active Upload Progress Tracking: The PHP configuration flag session.upload_progress.enabled must be set to 1 (On), which is the default setting in standard PHP distributions.
Configuration Directive Default Value Vulnerable Configuration Remediation State
session.serialize_handler (Global) php php_serialize or php_binary Standardise globally across all environments.
ini_set('session.serialize_handler') None Invoked dynamically with 'php' Remove dynamic runtime handler overrides.
session.upload_progress.enabled On (1) On (1) Set to Off (0) if upload tracking is unused.
session.auto_start Off (0) Off (0) (with explicit session_start) Ensure explicit, atomic session lifecycle control.

Default installations remain secure because they consistently utilize the same handler (usually php) throughout both the request startup phase (where upload progress data is intercepted) and the script execution phase (where session_start() is invoked). Without a mismatch between the write handler and the read handler, the session stream remains correctly formatted, preventing boundary injection.

Why do vulnerable code patterns exist in enterprise codebases? They typically emerge from legacy application migration efforts. When engineering teams upgrade older applications originally written for the php session handler to modern infrastructure running php_serialize, developers sometimes insert dynamic ini_set() switches into entrypoint bootstrapping scripts to preserve session compatibility for unpatched legacy modules without altering global server settings.

Contextualising the Shadow of PHP2Shell

The timing of CVE-2026-115560 is notable because it emerged immediately after the disclosure of CVE-2026-109619, widely referred to as PHP2Shell. According to reporting by SecurityWeek, the PHP2Shell vulnerabilities triggered immediate weaponisation, with threat actors initiating attacks within days—and in some cases prior to—the official vendor release.

While both vulnerabilities share common operational mitigations—specifically disabling file upload progress tracking via session.upload_progress.enabled = Off—their attack velocity and targeting criteria differ significantly:

  • PHP2Shell (CVE-2026-109619): Targetted broad file-upload primitives across default server profiles, making it an ideal candidate for automated mass-scanning frameworks and mass exploitation tools.
  • CVE-2026-115560: Requires specific configuration states that significantly narrow the target surface. However, where those configuration states exist, the impact remains catastrophic: unauthenticated remote code execution.

Release Cadence and Patch Management

PHP maintainers enforce a strict four-week release window. Security defects identified during or immediately following a release cycle are queued for the next scheduled update, requiring SRE teams to maintain continuous deployment readiness.

The rapid succession of core security issues highlights the operational risk of complex session handling mechanisms. Enterprise security teams often focus vulnerability management on third-party application dependencies while treating core runtime engines as monolithic black boxes. When underlying runtime components contain deserialization flaws triggered by subtle configuration drift, traditional network-level protections are often bypassed.

Evaluating Blast Radius for Enterprise Applications

Assessing whether an enterprise environment is exposed to CVE-2026-115560 requires auditing both infrastructure configuration files and application source code. The primary threat surface spans four specific operational architecture patterns.

1. Monolithic Legacy Codebases with Multi-Format Support

Large enterprise applications that have undergone multi-year migrations frequently harbor dynamic INI configuration toggles. It is common to find bootstrap scripts, legacy middleware, or global service providers that execute conditional statements based on client attributes or legacy cookie flags:

<?php
// Dangerous legacy pattern: Modifying session handler dynamically
if ($user->isLegacySession()) {
    ini_set('session.serialize_handler', 'php');
}
session_start();
?>

If the host environment sets session.serialize_handler = php_serialize globally within php.ini to accommodate modern API endpoints, the execution of the legacy code path creates the precise handler mismatch required to trigger CVE-2026-115560.

2. Shared Hosting and Multi-Tenant Environments

Multi-tenant web hosting architectures often allow tenant applications to override global PHP directives using custom .htaccess files, .user.ini files, or pool configurations in PHP-FPM. If the hosting provider configures a modern default like php_serialize at the root level, but an individual tenant site overrides the setting locally using ini_set() within their application entrypoint, that specific tenant application becomes vulnerable without the hosting provider’s explicit knowledge.

3. Custom Framework Session Drivers

Certain custom enterprise frameworks implement session wrappers that manually manage session startup, lock control, and serialization format switches. If a framework handler manipulates low-level session.serialize_handler directives during its lifecycle, any file upload handled by that framework endpoint must be carefully evaluated for exposure.

To identify affected execution paths across systems, operations teams should perform a structured discovery audit using system diagnostic tools:

# Step 1: Check active runtime configuration across all running FPM pools
php-fpm -i | grep -E "session.serialize_handler|session.upload_progress.enabled"

# Step 2: Audit local directory overrides (.user.ini / .htaccess)
find /var/www/ -type f \( -name ".user.ini" -o -name ".htaccess" \) -exec grep -H "session.serialize_handler" {} \;

Immediate Mitigation and Configuration Hardening

Applying upstream patches remains the definitive resolution for CVE-2026-115560. However, when immediate software updates cannot be deployed without extensive staging tests, organizations can implement immediate operational mitigations to neutralize the attack vector completely.

1. Disabling Session Upload Progress Tracking

The most effective mitigation—matching the advice issued for CVE-2026-109619—is to completely disable PHP’s session upload progress functionality. If an application does not actively read the $_SESSION upload progress buffer to display real-time client-side upload meters, this feature should be disabled across all production runtimes.

To disable upload progress globally, update the primary php.ini configuration file:

; System-wide mitigation for CVE-2026-115560 and CVE-2026-109619
session.upload_progress.enabled = Off

For systems using PHP-FPM, enforce this parameter across all worker pools within the pool configuration file (for example, /etc/php/8.3/fpm/pool.d/www.conf):

; Enforce via FPM pool configuration
php_admin_flag[session.upload_progress.enabled] = off

Utilizing php_admin_flag ensures that individual application scripts cannot re-enable the feature dynamically using ini_set() during request execution.

Operational Impact Notice

Disabling session.upload_progress.enabled prevents PHP from auto-populating upload telemetry into $_SESSION. It does not break standard file uploads using $_FILES or custom chunked upload scripts.

2. Aligning Global and Local Serialization Handlers

Organizations must audit their runtime environments to ensure that session handlers remain immutable. Standardise the global configuration across all web servers and strip runtime modification capabilities. If php_serialize is chosen, enforce it globally across all applications and remove any dynamic overrides.

3. Implementing WAF Filtering Rules

Web Application Firewalls (WAFs) can mitigate exploitation attempts by stripping or blocking HTTP requests containing upload progress triggers. By default, PHP inspects the POST body for a variable named PHP_SESSION_UPLOAD_PROGRESS (or whatever is defined by session.upload_progress.name).

In ModSecurity, administrators can deploy a custom blocking rule targeting multipart/form-data request payloads:

# ModSecurity Rule: Block HTTP requests attempting PHP session upload progress exploitation
SecRule REQUEST_FILENAME|ARGS_NAMES|ARGS "@contains PHP_SESSION_UPLOAD_PROGRESS" \
    "id:1000156, \
    phase:2, \
    deny, \
    status:403, \
    log, \
    msg:'CVE-2026-115560 - PHP Session Upload Progress Exploitation Attempt'"

For NGINX frontends acting as proxies to PHP-FPM, requests containing the upload progress parameter can be rejected prior to reaching the FastCGI backend:

# NGINX Location Block Filtering
if ($request_method = POST) {
    set $test_upload_progress "";
}
if ($content_type ~* "multipart/form-data") {
    set $test_upload_progress "A";
}
if ($args ~* "PHP_SESSION_UPLOAD_PROGRESS") {
    set $test_upload_progress "${test_upload_progress}B";
}
if ($test_upload_progress = "AB") {
    return 403;
}

Upgrade Procedures and Patch Management Strategy

PHP maintainers established the security release window for 19 November 2026 between 14:00 and 14:30 UTC. Enterprise operations teams must coordinate staging and deployment workflows to ensure updates are applied rapidly once packages are available from distribution repositories.

Orchestrating Patch Deployment Across Fleet Environments

When upgrading core language runtimes across distributed container clusters or virtual machine fleets, follow a structured verification pipeline:

  1. Verify Vendor Version Strings: Upstream release advisories list exact fixed version numbers at the time of publication. Confirm package availability within distribution mirrors (such as Ubuntu Security, Debian Security, RHEL AppStream, or Ondřej Surý’s PPA).
  2. Stage in Pre-Production: Deploy the candidate packages into a staging environment that mirrors production INI configurations. Validate that existing file upload workflows and session management components operate correctly under the patched binaries.
  3. Execute Graceful Service Reloads: Applying PHP upgrades in production does not strictly require full host reboots. For PHP-FPM architectures, issuing a graceful reload signal replaces master process workers without dropping active TCP connections or terminating long-running worker threads.
# Test configuration syntax prior to reloading FPM master process
php-fpm -t

# Issue graceful reload signal (SIGUSR2) to systemd service (test in staging)
systemctl reload php-fpm.service

In immutable containerised environments (such as Kubernetes deployments), update the base container images within CI/CD pipelines, execute automated smoke tests, and perform a rolling deployment across application deployments to achieve zero-downtime upgrades:

# Rollout patched container deployment (test in staging)
kubectl set image deployment/php-api-app php-fpm-container=internal-registry.example.com/php:8.3-patched --namespace=production
kubectl rollout status deployment/php-api-app --namespace=production

Defensive Code Audit and Static Analysis Patterns

Preventing vulnerable configuration states from entering production requires incorporating static analysis and code search rules into enterprise continuous integration pipelines.

1. Repository Scanning via Search Utilities

Security teams can perform immediate code audits across all internal Git repositories using `ripgrep` or standard `grep` utilities to identify dynamic session handler modifications:

# Search for dynamic session handler modifications in PHP codebases
rg -i "ini_set\s*\(\s*['\"]session\.serialize_handler['\"]" /path/to/source/code

# Search for upload progress references within session usage
rg -i "session\.upload_progress" /path/to/source/code

2. Semgrep Static Analysis Rules

To continuously enforce secure session configurations across developer pull requests, integrate automated rules into Semgrep static analysis workflows. The following rule flags any attempt to modify `session.serialize_handler` at runtime via `ini_set()`:

rules:
  - id: php-insecure-dynamic-session-handler
    languages:
      - php
    message: >-
      Dynamic modification of 'session.serialize_handler' via ini_set() creates severe
      deserialization vulnerabilities (CVE-2026-115560) when combined with upload progress tracking.
      Configure session handlers statically within global php.ini files.
    pattern-either:
      - pattern: ini_set('session.serialize_handler', $VALUE);
      - pattern: ini_set("session.serialize_handler", $VALUE);
    severity: ERROR
    metadata:
      cve: CVE-2026-115560
      category: security
      technology:
        - php

Common Mistakes in PHP Session Management Hardening

During security audits and emergency remediation exercises, engineering teams frequently make critical assumptions that compromise their defensive posture:

  • Assuming Default Safety Covers Multi-Tenant Configurations: Security teams often verify that global php.ini uses defaults, ignoring per-directory overrides (.user.ini) or framework entrypoints that alter settings dynamically.
  • Relying Exclusively on Framework ORMs: Developers assume that using modern framework ORMs or custom session handlers (like Redis or Memcached) inherently protects them. If the framework uses PHP’s native session initialization APIs underneath, low-level handler switches still trigger vulnerability paths.
  • Restarting Web Servers Without Checking FPM State: Systems administrators restart NGINX or Apache without issuing a reload or restart to the underlying `php-fpm` daemon, leaving vulnerable PHP processes active in memory.
  • Overlooking CI/CD Build Images: Organizations update production host packages but forget to update base Docker images used in deployment pipelines, leading to vulnerable code redeployments during subsequent software builds.

Key Takeaways for Securing PHP Runtimes

Managing the security posture of PHP runtimes requires continuous attention to system configurations and language-level defaults. CVE-2026-115560 reinforces essential principles for platform teams, SREs, and application security specialists:

  • Enforce Immutable Runtime Configuration: System settings like session.serialize_handler should be explicitly set at the environment level and locked against runtime alteration using php_admin_flag directives in PHP-FPM.
  • Reduce Global Feature Attack Surface: Features like automatic file-upload progress tracking provide limited functional value for modern web applications that rely on client-side JavaScript upload APIs. Unused native runtime features should be systematically disabled globally.
  • Integrate Static Analysis Security Testing (SAST): Catching dangerous initialization logic like dynamic ini_set() switches in code review prevents configuration drift before it enters production environments.
  • Maintain Rapid Patching Capabilities: Security updates follow tight operational windows. Operational teams must maintain automated build pipelines capable of building, testing, and deploying updated language packages within hours of vendor availability.

Frequently asked questions

What triggers CVE-2026-115560?

The vulnerability triggers when an application sets session.serialize_handler to php_binary or php_serialize in its server configuration and subsequently switches it to php at runtime via ini_set() prior to calling session_start(). Session upload progress tracking (session.upload_progress.enabled) must also be enabled during multipart upload processing.

Are default PHP installations vulnerable to CVE-2026-115560?

No. Standard, default PHP installations leave session.serialize_handler set to php continuously and do not switch session handlers dynamically during script execution. Without this dynamic handler mismatch, the session parser processes file upload telemetry normally and cannot be coerced into unsafe deserialization paths.

How does CVE-2026-115560 relate to PHP2Shell?

CVE-2026-115560 was publicly disclosed two days after PHP2Shell (CVE-2026-109619) made headlines. Both vulnerabilities reside within core PHP components and share a common operational mitigation: disabling session upload progress tracking. However, CVE-2026-115560 requires non-default configuration settings and runtime code execution conditions to exploit.

What is the immediate workaround if patching cannot be performed instantly?

The immediate workaround is disabling file upload progress tracking globally by setting session.upload_progress.enabled = Off in php.ini or enforcing php_admin_flag[session.upload_progress.enabled] = off in PHP-FPM pool configurations. Organizations should also audit source code to remove dynamic ini_set() modifications targeting session handlers.

Sources and further reading

This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.