Back to Intelligence

CVE-2026-115560: PHP Patches 7 Critical Flaws Including Unauthenticated RCE — Patching and Detection Guide

SA
Security Arsenal Team
November 20, 2026
10 min read

The PHP Foundation has released security updates addressing seven critical vulnerabilities affecting all supported PHP versions, including CVE-2026-115560, a flaw that can be leveraged to achieve unauthenticated remote code execution on affected deployments. The release was preceded by an advance notice from the maintainers — a step the PHP project reserves for genuinely severe issues — warning that the flaws were exploitable under specific, real-world configurations.

If you run PHP anywhere in your environment — and statistically, you do (PHP still powers the overwhelming majority of server-side web applications, including WordPress, Drupal, Laravel, and countless custom applications) — treat this as a drop-everything patch event. Unauthenticated RCE in the world's most deployed web language is exactly the class of vulnerability that gets weaponized within days of disclosure, and historically it is the class of bug that hands initial access brokers their next quarter's inventory.

Why This Matters Operationally

  • Unauthenticated code execution means no credentials, no session, no foothold required — an attacker who can reach your PHP endpoint can potentially execute arbitrary code as the web server user.
  • PHP deployments are frequently long-lived and under-patched, especially on shared hosting, embedded appliances, and legacy applications pinned to older runtimes.
  • Web server compromise is the classic entry point for webshell deployment, lateral movement, and ransomware staging — this is how a "web bug" becomes an enterprise incident.

Technical Analysis

Affected Products and Versions

Per the PHP Foundation's advisory, the flaws affect all supported PHP versions under specific configurations. Because the vulnerabilities span the language runtime itself (not a single extension), the exposure surface includes:

  • PHP-FPM deployments behind nginx or Apache (the dominant production pattern)
  • mod_php on Apache httpd
  • PHP CGI / FastCGI configurations — historically the configuration most exposed to request-smuggling and parameter-injection style attacks
  • Windows IIS deployments running PHP via FastCGI
  • Containerized PHP images (official php:* Docker Hub images) that will need to be rebuilt with patched base layers

Organizations should inventory not just bespoke applications but also appliances, control panels (cPanel, Plesk), monitoring frontends, and CI/CD tooling that bundle their own PHP runtime.

CVE-2026-115560: Unauthenticated Code Execution

CVE-2026-115560 is the headline flaw. While full technical details were held back in the advance-notice window to give defenders a head start, the critical facts for defenders are:

  • Pre-authentication exploitation — the vulnerable code path is reachable before any authentication or session establishment.
  • Configuration-dependent — exploitation requires the target to be running a specific (but common) configuration, which is precisely why the maintainers flagged "all supported versions under specific conditions" in the advance notice.
  • Remote code execution impact — successful exploitation yields code execution in the context of the PHP worker process (typically www-data, nginx, apache, or IIS APPPOOL\...).

From a defender's perspective, the exploitation chain follows the familiar pattern: a crafted HTTP request reaches the PHP interpreter, triggers the flaw, and causes the interpreter or the underlying worker to execute attacker-supplied instructions. The web worker then becomes the beachhead — expect webshell drops, reverse shells, and immediate credential/config harvesting (wp-config.php, .env files, /etc/passwd).

Exploitation Status

  • The PHP Foundation issued an advance notice before patch release, which strongly signals exploitability was considered realistic enough to warrant staged disclosure.
  • At time of writing, treat this as "exploitation imminent": mass scanning for newly disclosed PHP flaws historically begins within hours of patch release, as the patch diff itself reveals the vulnerable code path to anyone who can read C.
  • Check the CISA Known Exploited Vulnerabilities (KEV) catalog continuously over the coming days — PHP RCE flaws with unauthenticated reachability are prime KEV candidates, and a KEV listing carries a binding remediation deadline for federal civilian agencies (and should be treated as one by everyone else).

Detection & Response

The most reliable post-exploitation signal for PHP RCE is behavioral: the PHP interpreter or web server process spawning a shell or system command interpreter. Legitimate PHP applications do this rarely (image processing, mail sending), so baselining is essential, but sudden php-fpm → bash/sh/curl|sh chains in a production pool are almost always malicious.

Sigma Rules

YAML
---
title: PHP Worker Process Spawning Shell or Command Interpreter
id: 4f2a9c71-8b3d-4e5a-9c1f-7d6e5b4a3c2d
status: experimental
description: Detects PHP-FPM, mod_php, or PHP-CGI spawning shells or command interpreters, consistent with post-exploitation of a PHP RCE flaw such as CVE-2026-115560. Webshells and exploit payloads almost universally invoke sh/bash via system(), exec(), passthru(), or shell_exec().
references:
  - https://thehackernews.com/2026/11/php-fixes-7-critical-flaws-including.html
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/13
tags:
  - attack.execution
  - attack.t1059.004
  - attack.t1190
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/php-fpm'
      - '/php-cgi'
      - '/php'
      - '/apache2'
      - '/httpd'
      - '/nginx'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/zsh'
      - '/curl'
      - '/wget'
      - '/nc'
      - '/ncat'
      - '/python'
      - '/python3'
      - '/perl'
  condition: selection_parent and selection_child
falsepositives:
  - Legitimate application use of exec()/shell_exec() for image processing or mail
  - Package managers in deployment pipelines — scope to production hosts
level: high
---
title: PHP Process Writing Executable Content to Web-Accessible Directory
id: 8e1b5d92-4c6f-4a7b-b2e3-9f8c7d6a5b4c
status: experimental
description: Detects PHP or web server processes creating new PHP files in web-accessible directories, a hallmark of webshell deployment following exploitation of an RCE vulnerability like CVE-2026-115560.
references:
  - https://thehackernews.com/2026/11/php-fixes-7-critical-flaws-including.html
  - https://attack.mitre.org/techniques/T1505/003/
author: Security Arsenal
date: 2026/11/13
tags:
  - attack.persistence
  - attack.t1505.003
logsource:
  category: file_event
  product: linux
detection:
  selection_image:
    Image|endswith:
      - '/php-fpm'
      - '/php-cgi'
      - '/apache2'
      - '/httpd'
      - '/nginx'
  selection_target:
    TargetFilename|endswith:
      - '.php'
      - '.phtml'
      - '.phar'
      - '.php5'
      - '.php7'
  selection_paths:
    TargetFilename|contains:
      - '/var/www/'
      - '/srv/www/'
      - '/usr/share/nginx/'
      - '/htdocs/'
  condition: selection_image and selection_target and selection_paths
falsepositives:
  - Application deployment pipelines and CMS plugin/theme installers — filter by deployment service accounts and known deploy windows
level: high

KQL (Microsoft Sentinel / Defender)

This query hunts for PHP or web server processes spawning command interpreters, using process creation telemetry ingested into Sentinel via Syslog/CEF from Linux hosts or via Defender for Endpoint. Run it over at least the last 7 days and compare against your deployment baseline.

KQL — Microsoft Sentinel / Defender
let phpParents = dynamic(["php-fpm", "php-cgi", "php", "apache2", "httpd", "nginx"]);
let shellChildren = dynamic(["sh", "bash", "dash", "zsh", "curl", "wget", "nc", "ncat", "python", "python3", "perl"]);
union isfuzzy=true
  (DeviceProcessEvents
    | where TimeGenerated > ago(7d)
    | where InitiatingProcessFileName in~ (phpParents)
    | where FileName in~ (shellChildren)
    | project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, AccountName),
  (Syslog
    | where TimeGenerated > ago(7d)
    | where SyslogMessage has_any ("php-fpm", "php-cgi", "apache2", "httpd")
    | where SyslogMessage has_any ("/bin/sh", "/bin/bash", "shell_exec", "passthru")
    | project TimeGenerated, Computer, ProcessName, SyslogMessage)
| order by TimeGenerated desc

A companion network hunt: PHP workers initiating outbound connections to uncommon external IPs shortly after inbound web hits is a strong post-exploitation signal (reverse shells, payload staging). Pivot DeviceNetworkEvents on InitiatingProcessFileName in~ (phpParents) joined to inbound HTTP logs by time window.

Velociraptor VQL

Use this hunt artifact across Linux web servers to identify suspicious child processes of PHP workers and recently created PHP files in web roots — the two artifacts that matter most after an RCE event.

VQL — Velociraptor
-- Hunt for suspicious children of PHP/web server processes and recently dropped web files
LET proc_hunt = SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ '(/bin/(ba)?sh|curl|wget|nc |python|perl)'
  AND Name =~ '(sh|bash|curl|wget|nc|python|perl)'

LET webshell_hunt = SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs=['/var/www/**/*.php', '/srv/www/**/*.php', '/usr/share/nginx/**/*.php'])
WHERE Mtime > now() - 604800
  AND FullPath !~ '(wp-content/uploads/.+\\.(jpe?g|png))'

SELECT * FROM proc_hunt
UNION ALL
SELECT NULL AS Pid, NULL AS Ppid, 'FILE:' + FullPath AS Name, NULL AS Exe,
       FullPath AS CommandLine, NULL AS Username, Mtime AS CreateTime
FROM webshell_hunt

Verification and Hardening Script

The following Bash script inventories installed PHP versions across common package managers, checks them against the patched release lines published by the PHP Foundation, and applies basic hardening while you patch. Run it on every web tier host; for container fleets, rebuild images with patched base layers instead.

Bash / Shell
#!/bin/bash
# PHP critical patch verification & interim hardening — CVE-2026-115560 response
# Run as root. Test in staging before production use.

set -euo pipefail

echo "=== [1/4] Installed PHP version inventory ==="
if command -v php >/dev/null 2>&1; then
  php -v | head -n 1
else
  echo "No system php binary found — check for bundled/containerized runtimes."
fi
php-fpm -v 2>/dev/null | head -n 1 || true
dpkg -l 2>/dev/null | grep -Ei 'php[0-9.]*-(fpm|cli|cgi)' || true
rpm -qa 2>/dev/null | grep -Ei '^php' || true

echo "=== [2/4] Checking for exposed PHP-CGI/FastCGI listeners ==="
ss -tlnp 2>/dev/null | grep -Ei 'php|9000' || echo "No PHP TCP listeners found (unix socket or not installed)."

echo "=== [3/4] Applying vendor security updates (choose your distro path) ==="
if command -v apt-get >/dev/null 2>&1; then
  apt-get update -qq
  apt-get --only-upgrade install -y 'php*' || echo "Review apt output — verify new version against PHP advisory."
elif command -v dnf >/dev/null 2>&1; then
  dnf update -y 'php*'
elif command -v yum >/dev/null 2>&1; then
  yum update -y 'php*'
fi

echo "=== [4/4] Interim hardening (idempotent) ==="
# Disable dangerous functions as defense-in-depth until patched versions are confirmed
for ini in $(php --ini 2>/dev/null | grep -oP '(?<=: )/.*\.ini' || true); do
  if ! grep -q 'disable_functions' "$ini"; then
    echo 'disable_functions = exec,passthru,shell_exec,system,proc_open,popen' >> "$ini"
    echo "Hardened: $ini"
  fi
done
# Restart FPM to pick up config and patched binaries
systemctl list-units --type=service | grep -oP 'php[0-9.]*-fpm(?=\.service)' | while read -r svc; do
  systemctl restart "$svc" && echo "Restarted $svc"
done

echo "=== DONE — confirm running version matches the patched release in the PHP advisory ==="
php -v | head -n 1

Note: The disable_functions hardening is a compensating control, not a fix — some CMS plugins depend on these functions. Validate in staging, and remove the override only after the patched runtime is confirmed.


Remediation

  1. Patch immediately. Apply the security releases published by the PHP Foundation to all supported version lines (8.1/8.2/8.3/8.4 branches and any maintained LTS lines per the advisory). Confirm the running version — not just the installed package — with php -v and php-fpm -v, and restart FPM/Apache so the patched binary is actually in memory. Official sources:
  2. Rebuild containers. Patching the host does nothing for your Docker images. Pull the refreshed official php:* base images and redeploy; scan running containers for stale runtimes.
  3. Hunt before you trust. Apply the detections above retroactively across the last 30 days. If you find php-fpm → sh/bash chains or new .php files in web roots, treat the host as compromised: isolate, capture memory/disk, and run IR — do not just patch and move on.
  4. Reduce the attack surface. Take any PHP-CGI/FastCGI listeners off public interfaces; ensure FPM binds to a unix socket or localhost. Place a WAF rule set (OWASP CRS at minimum) in front of internet-facing PHP applications while patching completes.
  5. Inventory the shadow PHP. Enumerate appliances, control panels, and third-party software bundling PHP. Vendor appliances will ship patches on their own schedule — open tickets now and document compensating controls in the interim.
  6. Watch CISA KEV. If CVE-2026-115560 (or any of the seven flaws) lands in KEV, federal agencies face a binding remediation deadline — and you should treat that deadline as your own, because KEV listing means confirmed active exploitation.
  7. Fix the process gap. PHP RCEs are a recurring event class. Ensure your vulnerability management program can push web-tier runtime patches on an emergency (24–72 hour) SLA, and that internet-facing runtimes are continuously inventoried.

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.