Back to Intelligence

CVE-2026-115560: PHP Session Upload Progress RCE — Detection and Remediation Guide

SA
Security Arsenal Team
November 20, 2026
13 min read

Barely two days after patches landed for the PHP2Shell flaws, the PHP project has confirmed it is preparing another round of critical security updates — this time for CVE-2026-115560, a code execution vulnerability in PHP's session upload progress mechanism. If your organization runs PHP in production — and statistically, it does, given PHP powers the majority of the web — this is a stop-what-you're-doing moment. A code execution flaw in a core, widely-enabled PHP feature, disclosed while exploitation momentum around PHP is already high, is exactly the kind of bug that gets weaponized fast.

What Happened

According to SecurityWeek's reporting, CVE-2026-115560 affects PHP's session upload progress feature — the functionality that lets developers track file upload state via the PHP_SESSION_UPLOAD_PROGRESS request parameter. The flaw was publicly disclosed just two days after the PHP2Shell patches shipped, which means attackers were watching the same disclosure channels defenders were. The proximity to the PHP2Shell patch cycle matters: threat actors who operationalized that bug already have tooling, target lists, and infrastructure primed for PHP exploitation. A second, adjacent RCE is a gift to anyone mid-campaign.

At the time of writing, vendor-fixed packages are being readied but have not fully propagated to all distributions. That gap between disclosure and available patches is your exposure window — and it is precisely why the detection and workaround guidance below matters.

Technical Analysis

Affected Component

The vulnerability resides in PHP's session upload progress handling, introduced in PHP 5.4 and enabled by default in virtually every modern PHP deployment via session.upload_progress.enabled = On in php.ini. When a multipart POST request includes the PHP_SESSION_UPLOAD_PROGRESS key, PHP writes attacker-influenced data into a session file under the configured session save path (commonly /var/lib/php/sessions/ or /tmp/sess_*).

The classic abuse pattern for this feature — well documented in CTF and offensive research circles — involves racing session file writes to inject attacker-controlled content that is subsequently included or deserialized, yielding code execution. CVE-2026-115560 escalates this from a conditional, configuration-dependent technique into a remotely triggerable code execution flaw in the feature itself. From a defender's standpoint, treat any externally reachable PHP endpoint that accepts POST data as potentially exposed.

Affected Versions and Platforms

Because the session upload progress feature spans all actively supported PHP branches, defenders should assume exposure across:

  • PHP 8.1, 8.2, 8.3, and 8.4 release lines (and end-of-life branches, which will never receive a fix)
  • Any web server fronting PHP: Apache with mod_php, Nginx/Apache with PHP-FPM, and PHP-CGI deployments
  • All major Linux distributions shipping vendor PHP packages (RHEL/Rocky/Alma, Debian/Ubuntu, SLES), plus containerized PHP images and Windows/IIS PHP-CGI installs

Verify your exact exposure with php -v and your distribution's security tracker. Until your vendor publishes a patched build mapped to CVE-2026-115560, assume the installed version is vulnerable.

Exploitation Requirements and Chain

From a defender's perspective, the attack chain looks like this:

  1. Attacker sends crafted POST requests (frequently multipart) to any reachable PHP script, embedding the PHP_SESSION_UPLOAD_PROGRESS parameter with malicious content.
  2. The vulnerable session upload progress handler writes attacker-influenced data into a session file in the session save path.
  3. The flaw in that handling path is leveraged to achieve code execution in the context of the web server / PHP-FPM worker user (typically www-data, apache, or nginx).
  4. Post-exploitation follows the standard PHP web shell playbook: dropping a .php webshell in a web-accessible directory, pulling second-stage tooling with curl/wget, and spawning interactive shells.

Exploitation Status

The flaw is publicly disclosed with vendor patches in preparation — meaning technical detail is circulating in the open while many environments remain unpatched. Historical precedent (the PHP-CGI argument injection flaw CVE-2024-4577, weaponized within days, and the recent PHP2Shell campaign) tells us that public PHP RCE details get folded into scanners and botnets within hours to days. Treat this as imminent exploitation risk, not theoretical. At the time of publication, monitor the CISA KEV catalog for addition, and track the official advisories at php.net and your distribution's security feed for patched version numbers.

Detection & Response

Your highest-fidelity detections focus on the two observable artifacts of this attack: (1) requests carrying PHP_SESSION_UPLOAD_PROGRESS — a parameter with essentially zero legitimate use in most production traffic patterns — and (2) the web server / PHP process doing things it should never do, like spawning shells or writing executable PHP files into temp or upload directories.

Sigma Rules

YAML
---
title: Web Server or PHP Process Spawning Shell or Downloader
id: 3f8a1c92-7d4e-4b6a-9c51-2e8d5f0a7b3c
status: experimental
description: Detects PHP-FPM, Apache, or Nginx worker processes spawning shells, downloaders, or interpreters — a strong post-exploitation indicator for PHP RCE flaws such as CVE-2026-115560.
references:
  - https://www.securityweek.com/php-readies-critical-security-updates-to-patch-another-rce-flaw/
  - https://attack.mitre.org/techniques/T1059/
  - https://attack.mitre.org/techniques/T1105/
author: Security Arsenal
date: 2026/02/10
tags:
  - attack.execution
  - attack.t1059.004
  - attack.t1105
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/php-fpm'
      - '/php-fpm8.1'
      - '/php-fpm8.2'
      - '/php-fpm8.3'
      - '/php-fpm8.4'
      - '/apache2'
      - '/httpd'
      - '/php-cgi'
      - '/nginx'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/curl'
      - '/wget'
      - '/python'
      - '/python3'
      - '/perl'
      - '/nc'
      - '/ncat'
      - '/base64'
      - '/chmod'
  condition: selection_parent and selection_child
falsepositives:
  - Legitimate PHP applications invoking system utilities (backup scripts, image processing, mail handlers) — baseline per application and tune
level: high
---
title: PHP Session Upload Progress Parameter in Web Requests
id: 8c2d5e17-4a9f-4b83-ad62-1f7c3e90b4d5
status: experimental
description: Detects inbound web requests referencing PHP_SESSION_UPLOAD_PROGRESS, the request parameter abused by CVE-2026-115560 and prior session upload progress attack techniques. Rare in legitimate external traffic.
references:
  - https://www.securityweek.com/php-readies-critical-security-updates-to-patch-another-rce-flaw/
  - https://attack.mitre.org/techniques/T1190/
author: Security Arsenal
date: 2026/02/10
tags:
  - attack.initial_access
  - attack.t1190
logsource:
  category: webserver
detection:
  selection:
    c-uri|contains:
      - 'PHP_SESSION_UPLOAD_PROGRESS'
  condition: selection
falsepositives:
  - Legitimate file upload forms using the native PHP upload progress feature — expect a low and steady baseline; alert on spikes, new sources, or requests to endpoints that do not host upload forms
level: medium
---
title: Web Server Process Writing PHP File to Temp or Upload Directory
id: 5e1b9f04-3c8a-4d72-bf46-9a2c6d1e8357
status: experimental
description: Detects PHP/Apache/Nginx worker processes creating .php files in temporary, session, or upload directories — consistent with webshell deployment following exploitation of a PHP RCE such as CVE-2026-115560.
references:
  - https://www.securityweek.com/php-readies-critical-security-updates-to-patch-another-rce-flaw/
  - https://attack.mitre.org/techniques/T1505/003/
author: Security Arsenal
date: 2026/02/10
tags:
  - attack.persistence
  - attack.t1505.003
logsource:
  category: file_event
  product: linux
detection:
  selection_image:
    Image|endswith:
      - '/php-fpm'
      - '/apache2'
      - '/httpd'
      - '/php-cgi'
      - '/nginx'
  selection_path:
    TargetFilename|contains:
      - '/tmp/'
      - '/dev/shm/'
      - '/var/lib/php/sessions/'
      - '/uploads/'
      - '/upload/'
  selection_ext:
    TargetFilename|endswith:
      - '.php'
      - '.phtml'
      - '.phar'
      - '.php5'
      - '.php7'
      - '.php8'
  condition: all of selection_*
falsepositives:
  - Application installers, cache builders, and CMS media handlers — tune per application path
level: high

A note on the second rule: PHP_SESSION_UPLOAD_PROGRESS is normally transmitted in the POST body, so URI-based detection only catches a subset. If your proxy or WAF logs request bodies (ModSecurity audit logs, for example), extend the search there — that's where the real signal lives.

KQL — Microsoft Sentinel / Defender

PHP estates are predominantly Linux, so this hunts via Syslog (Sysmon for Linux process creation) and web/proxy logs ingested through CEF. Run it across your full retention window, not just the last 24 hours — disclosure was public, and quiet testing may predate your awareness.

KQL — Microsoft Sentinel / Defender
// Hunt 1: PHP/web server processes spawning shells or downloaders (post-exploitation)
Syslog
| where TimeGenerated > ago(14d)
| where ProcessName has_any ("sh", "bash", "dash", "curl", "wget", "nc", "ncat", "python", "python3", "perl", "base64")
| extend SyslogMsg = tostring(SyslogMessage)
| where SyslogMsg has_any ("php-fpm", "apache2", "httpd", "php-cgi", "nginx")
| project TimeGenerated, Computer, ProcessName, SyslogMsg, HostIP
| order by TimeGenerated desc
;
// Hunt 2: Inbound requests referencing the abused upload progress parameter (via CEF/proxy ingestion)
CommonSecurityLog
| where TimeGenerated > ago(14d)
| where RequestURL has "PHP_SESSION_UPLOAD_PROGRESS"
   or AdditionalExtensions has "PHP_SESSION_UPLOAD_PROGRESS"
| summarize Requests = count(), Destinations = dcount(DestinationHostName) by SourceIP, DestinationHostName, RequestMethod, bin(TimeGenerated, 1h)
| order by Requests desc
;
// Hunt 3: Webshell staging — .php files created in temp/session/upload paths (Sysmon file events via Syslog)
Syslog
| where TimeGenerated > ago(14d)
| where SyslogMessage has_all ("FileCreate", ".php")
| where SyslogMessage has_any ("/tmp/", "/dev/shm/", "/var/lib/php/sessions/", "/uploads/")
| project TimeGenerated, Computer, SyslogMessage
| order by TimeGenerated desc

Tuning guidance: Hunt 2's spike detection is the money query. A single source IP hitting dozens of distinct PHP endpoints with PHP_SESSION_UPLOAD_PROGRESS is an attacker probing for a vulnerable handler. Legitimate upload forms produce low-volume, single-endpoint traffic from normal user sessions.

Velociraptor VQL

For rapid fleet-wide triage of PHP servers, this artifact identifies suspicious child processes of web server and PHP-FPM parents, plus netstat correlation to catch established reverse shells.

VQL — Velociraptor
-- PHP RCE post-exploitation triage: suspicious children of web/PHP processes
LET procs = SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()

LET parents = SELECT Pid, Name AS ParentName
FROM pslist()
WHERE Name =~ '(?i)(php-fpm|php-cgi|apache2?|httpd|nginx)'

SELECT p.Pid, p.Ppid, pa.ParentName, p.Name AS ChildName,
       p.CommandLine, p.Username, p.CreateTime
FROM procs AS p
JOIN parents AS pa ON p.Ppid = pa.Pid
WHERE p.Name =~ '(?i)^(sh|bash|dash|curl|wget|nc|ncat|python3?|perl|base64|chmod|socat)$'
   OR p.CommandLine =~ '(?i)(/dev/tcp/|base64 -d|chmod \+x|wget http|curl .*http)'

-- Correlate: web processes holding unexpected outbound connections
SELECT Pid, Name, CommandLine, RemoteAddress, RemotePort, State
FROM netstat()
WHERE Name =~ '(?i)(php-fpm|apache2?|httpd|nginx|sh|bash)'
  AND State =~ 'ESTABLISHED'
  AND RemotePort NOT IN (80, 443, 3306, 5432, 6379, 11211)
  AND RemoteAddress !~ '^(10\\.|172\\.(1[6-9]|2[0-9]|3[01])\\.|192\\.168\\.|127\\.)'

The netstat section flags web processes holding established connections to non-RFC1918 addresses on non-standard ports — a pattern consistent with reverse shells or C2 beacons, and rare in healthy PHP workloads that mostly talk to local databases and upstream proxies.

Remediation and Hardening Script

Run this Bash audit on every PHP host. It reports your PHP version and EOL status, checks whether session upload progress is enabled, applies the workaround (disabling the feature) if you opt in, and sweeps recent web logs for probe activity.

Bash / Shell
#!/bin/bash
# CVE-2026-115560 triage & workaround — run as root or via sudo
# Usage: sudo bash php_cve_2026_115560_triage.sh [--apply-workaround]

echo "=== [1] PHP version and branch ==="
php -v 2>/dev/null || echo "php CLI not found in PATH — check /usr/bin/php* and FPM pools"
for BIN in /usr/bin/php*; do [ -x "$BIN" ] && echo "$BIN => $($BIN -r 'echo PHP_VERSION;' 2>/dev/null)"; done

echo ""
echo "=== [2] session.upload_progress.enabled status across all php.ini files ==="
grep -Rni --include="*.ini" "session.upload_progress.enabled" /etc/php* /etc/php*/*/ 2>/dev/null || echo "Setting not explicitly defined (defaults to On)"

echo ""
echo "=== [3] Probe activity: PHP_SESSION_UPLOAD_PROGRESS in recent web logs ==="
for LOG in /var/log/nginx/access.log /var/log/apache2/access.log /var/log/httpd/access_log; do
  [ -f "$LOG" ] && echo "--- $LOG ---" && grep -c "PHP_SESSION_UPLOAD_PROGRESS" "$LOG" 2>/dev/null
done
zgrep -h "PHP_SESSION_UPLOAD_PROGRESS" /var/log/nginx/access.log*.gz /var/log/apache2/access.log*.gz 2>/dev/null | awk '{print $1}' | sort | uniq -c | sort -rn | head -20

echo ""
echo "=== [4] Pending security updates for PHP packages ==="
if command -v apt-get >/dev/null; then
  apt list --upgradable 2>/dev/null | grep -i php
elif command -v dnf >/dev/null; then
  dnf check-update --security 2>/dev/null | grep -i php
elif command -v yum >/dev/null; then
  yum check-update --security 2>/dev/null | grep -i php
fi

echo ""
echo "=== [5] Suspicious .php files in temp/session/upload paths (last 7 days) ==="
find /tmp /dev/shm /var/lib/php/sessions /var/www/*/uploads -name "*.php" -o -name "*.phtml" -o -name "*.phar" 2>/dev/null | while read -r F; do
  find "$F" -mtime -7 -exec ls -la {} \; 2>/dev/null
done

if [ "$1" = "--apply-workaround" ]; then
  echo ""
  echo "=== [6] Applying workaround: disabling session upload progress ==="
  for INI in $(php --ini 2>/dev/null | grep -oP '(?<=: )/[^,]+' | tr ',' '\n') /etc/php*/fpm/php.ini /etc/php*/apache2/php.ini /etc/php*/cli/php.ini; do
    if [ -f "$INI" ]; then
      if grep -q "^session.upload_progress.enabled" "$INI"; then
        sed -i 's/^session.upload_progress.enabled.*/session.upload_progress.enabled = Off/' "$INI"
      else
        echo "session.upload_progress.enabled = Off" >> "$INI"
      fi
      echo "Hardened: $INI"
    fi
  done
  echo "Restart PHP-FPM/Apache to apply: systemctl restart php*-fpm apache2 (or httpd)"
fi

echo ""
echo "Triage complete. If probe counts in step 3 are non-zero, escalate to IR before patching — capture logs and session files first."

Remediation

1. Patch as soon as vendor builds land. The PHP project is actively preparing releases for CVE-2026-115560. Subscribe to the PHP announcements list and your distribution's security feed (Debian Security Tracker, Red Hat/errata, Ubuntu Security Notices) and apply patched php, php-fpm, and mod_php packages the day they publish. If this vulnerability is added to the CISA KEV catalog, the associated remediation deadline applies to federal agencies — and should drive your SLA regardless of sector.

2. Apply the workaround immediately if you cannot patch today. Set session.upload_progress.enabled = Off in every php.ini (FPM, Apache, CLI) and restart the relevant services. Verify your application doesn't depend on the native upload progress UI first — most modern apps use JavaScript-based progress bars and won't notice.

3. Deploy a WAF compensating control. Block or alert on requests containing the string PHP_SESSION_UPLOAD_PROGRESS at your WAF, reverse proxy, or CDN edge. For ModSecurity, a simple chained rule matching ARGS_NAMES against that parameter is effective. This buys detection and blocking coverage while patches propagate.

4. Audit for pre-patch compromise. Patching does not evict an attacker who got in during the exposure window. Sweep for .php files in temp/session/upload paths, review access logs for the probe pattern in the KQL hunt above, and check for unexpected outbound connections from web server processes. If you find post-exploitation artifacts, treat it as an incident: isolate the host, capture memory and the session directory, and begin scoping lateral movement.

5. Reduce the standing attack surface. This is the second critical PHP code execution issue in a single patch cycle. Take the hint: retire EOL PHP branches (anything below 8.1 receives no fixes, ever), run PHP-FPM under dedicated least-privilege pool users with open_basedir restrictions, disable allow_url_include, and remove PHP execution from upload and temp directories via web server configuration (php_admin_flag engine off or equivalent location blocks).

6. Validate detection coverage. Deploy the Sigma rules and KQL hunts above before the patch wave, not after — the exploitation window between disclosure and your patch deployment is exactly when you need eyes on.

The pattern here should concern every security program: PHP's core feature set keeps producing remotely exploitable flaws, and the time-to-weaponization on PHP RCEs is measured in days. Organizations that treat PHP patching as a routine monthly task will be on the wrong side of the next headline. Build the workaround, the WAF rule, and the hunts into your standard response playbook for interpreter-level flaws — you will use them again.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.