Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach PHP HTTP endpoint (AV:N)
-
DeliverySend crafted multipart request
-
ExploitForce OOM during early body parsing
-
ExecutionCorrupt partially-initialized request memory (UAF)
-
PersistShutdown branches on invalid state
-
ImpactExecute code as web worker
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | No authentication and no user interaction are required (PR:N/UI:N): the flaw is reached during PHP's automatic request body parsing before any application code executes. The confirmed exploitation path requires the Apache mod_php SAPI, which unconditionally runs the request shutdown procedure even after request startup fails, and was validated against default PHP input and memory limits with normal prefork, multi-worker configurations. The concrete trigger is a multipart/form-data request abusing multipart parsing (e.g. a multipart body without a usable declared content length that still supplies decoded data, an unbounded number of per-part headers that cost far more memory in PHP than on the wire, or empty file controls with nested field names) to drive the worker to OOM while request memory is only partially initialized. A predictable finite per-request memory_limit is what makes the OOM controllable. LIMITING FACTORS: reliability depends on PHP build, extensions, frontend behavior and allocator layout (AC:H/AT:P), and additional workers plus unrelated traffic can raise the number of attempts needed though they do not remove the condition. PHP-FPM exits the child on startup failure, which prevents the application-independent startup path and makes complete exploitation unproven for FPM (startup-independent OOM paths remain theoretically susceptible); FrankenPHP is likely susceptible like mod_php, and LSAPI is modeled on FPM with only likely, unvalidated application-specific exploits. Deployments that do not use multipart form data can block such requests at the frontend before they reach PHP. |
| Impact | This is a genuine top-priority vulnerability, not a high-CVSS paper tiger. The GHSA advisory confirms unauthenticated remote code execution as the web worker account, validated over HTTP against Apache mod_php using default PHP input and memory limits and normal prefork multi-worker configurations - i.e. out-of-the-box deployments, not an exotic edge case. The CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H, score 9.2) agrees: network reach, no privileges, no user interaction, total confidentiality/integrity/availability impact. The AC:H and AT:P metrics reflect that exploit portability and reliability depend on the PHP build, extensions, frontend behavior and allocator layout, and that additional workers and unrelated traffic can increase the number of attempts required - the advisory grounds this explicitly rather than it being a race or timing assumption. A public exploit reference and a confirmed public PoC are present (vendor Ubuntu, wiz.io php2shell writeup, and a gist marked as exploit), and the vuln.today Decision label is act_now. The one conflicting signal is SSVC, which reports Exploitation: none and Automatable: no despite a confirmed public PoC and act_now label - treat the SSVC exploitation value as stale/conservative rather than as evidence of low risk, since the GHSA explicitly describes a confirmed working exploit. No EPSS score was provided, so probabilistic exploitation likelihood could not be weighed. The CVE is not listed in CISA KEV at time of analysis. SSVC Technical Impact: total is consistent with RCE. Net: for any internet-facing mod_php (and likely FrankenPHP) deployment this is an emergency-grade patch item. |
| Exploit ScenarioDerived | An unauthenticated attacker sends a crafted multipart/form-data HTTP request to an Apache mod_php site that, during automatic request body parsing before any application code runs, drives the process into an out-of-memory condition while request memory is only partially initialized; the request shutdown procedure then operates on this invalid use-after-free state, giving remote code execution as the web worker account. A public PoC/exploit reference exists (confirmed), and the php2shell writeup documents the technique, so weaponization effort is low, though reliability varies with build, extensions, frontend and allocator layout and may require multiple attempts under load. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv5 – Oct 22, 2026
Unauthenticated remote code execution in PHP 8.2.x before 8.2.35, 8.3.x before 8.3.36, 8.4.x before 8.4.27, and 8.5.x before 8.5.12 arises when an attacker drives a worker into an out-of-memory condition while request memory is only partially initialized, leaving freed/reused structures that the request shutdown path then processes. Exploitation is confirmed practical against Apache mod_php with default input and memory limits in normal multi-worker prefork setups, and publicly available exploit code exists; the vendor and distros (Ubuntu USN-8948-1) have released fixed builds. With a 9.2 CVSS score, a public PoC, and an act_now priority decision, this warrants immediate patching, though reliability varies with build, extensions, frontend behavior and allocator layout, and no complete PHP-FPM exploit has been demonstrated.
Earlier versions of this analysis (4)
Unauthenticated remote code execution in PHP affects the 8.2.x, 8.3.x, 8.4.x and 8.5.x branches (fixed in 8.2.35, 8.3.36, 8.4.27 and 8.5.12) and is driven by an out-of-memory condition during automatic multipart request body parsing, which leaves request memory in an invalid state that request shutdown later processes. Complete RCE was validated over HTTP against Apache mod_php with default PHP input and memory limits and normal prefork configurations, so no application cooperation is needed; FPM is susceptible by source analysis but no complete exploit has been demonstrated there, while FrankenPHP and LSAPI are assessed likely susceptible but unvalidated. Publicly available exploit code exists (confirmed), a gist and a vendor-style write-up are referenced, and the vulnerability is tracked under an act_now priority with total technical impact; reliability depends heavily on build, extensions, frontend behavior and allocator layout (AC:H/AT:P), and mitigated deployments using a finite PHP memory_limit remain the primary exposure.
Unauthenticated remote code execution in PHP 8.2.x, 8.3.x, 8.4.x and 8.5.x stems from PHP using longjmp() to bail out of out-of-memory conditions, which can abandon request memory that is temporarily reachable but not fully initialized; the request-shutdown procedure may then read or branch on that invalid state, and multiple OOM strategies during automatic multipart/form-data parsing can reach it consistently. Complete RCE was validated over HTTP against Apache mod_php with default PHP input and memory limits and a normal prefork configuration with multiple workers, so this is a genuine high-priority issue rather than a high-CVSS-but-low-real-risk case, and it carries an act_now priority with publicly available exploit code (a PoC gist) even though there is no CISA KEV entry and SSVC records exploitation as none. Vendor patches are released in PHP 8.2.35, 8.3.36, 8.4.27 and 8.5.12, and the vendor states that updating is the only complete mitigation.
Use-after-free in PHP (php-src) can be exploited by unauthenticated remote attackers to achieve code execution, with high confidentiality, integrity, and availability impact. The CVSS 4.0 vector requires attacker-uncontrolled conditions (AC:H and AT:P), so reliable exploitation depends on winning heap-reuse or timing conditions in the vulnerable code path; no public exploit was identified at time of analysis. Vendor patches are available through the php-src advisory and Ubuntu Security Notice USN-8948-1.
Remote code execution is reported in an unspecified Ubuntu package, but the available intelligence does not identify the affected component, Ubuntu release, version range, or CVSS vector. Defenders cannot confirm the attack vector, required privileges, user interaction, or whether default configurations are exposed; these details must come from the Ubuntu Security Notice. No active exploitation or public exploit code is indicated in the provided data.
RemediationAI
Upgrade to the vendor-fixed releases: PHP 8.2.35, 8.3.36, 8.4.27 or 8.5.12 (upstream advisory GHSA-w8hw-w9fx-j79w; Ubuntu users should apply USN-8948-1). The vendor states that updating to a patched PHP release is the only complete mitigation, and that remediation advice from the related advisory GHSA-6wmf-4rv5-p3rp should also be followed. For installations that cannot update immediately, the primary configuration workaround is to set and enforce memory_limit=-1 administratively, removing the predictable finite per-request limit the confirmed OOM-based exploit depends on - but this is not complete, since an mmap() or other underlying allocation failure can still reach the vulnerable longjmp() path, and every PHP worker must be restarted with confirmation that no pool, directory or application setting restores a finite limit. Do not use RLIMIT_AS or RLIMIT_DATA, which cause mmap() to fail at the limit and re-enter the vulnerable path; a cgroup memory.max limit is only a partial substitute and may kill the master and all workers unless each worker has its own group. Keep post_max_size conservative, independently enforce decoded request size at the frontend, and bound max_input_nesting_level, the number of input variables, multipart parts, per-part headers and uploads; deployments that do not use multipart form data should block such requests at the frontend before they reach PHP.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 4 packages in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is a use-after-free class defect (CWE-416) in PHP's out-of-memory error handling. PHP historically uses longjmp() to abort request processing on OOM, but during request startup some request memory (notably multipart/form-data parsing state built by automatic body parsing) is temporarily reachable before it is fully initialized; if any allocation fails at that point, the early exit is not accounted for and the request memory is left invalid, so the request shutdown procedure may later read or branch on it - enabling memory corruption and code execution. The trigger is not related to the failed allocation itself. The advisory enumerates several OOM strategies that stay within apparent PHP limits: a multipart request with no usable declared content length that passes post_max_size and keeps supplying decoded body data, multipart parts carrying an unrestricted number of headers whose in-memory representation costs far more than the wire form, and empty file controls (exempt from max_file_uploads) with nested field names that multiply array work; application-specific large allocations can also reach OOM. Susceptibility is SAPI-dependent: Apache mod_php unconditionally invokes request shutdown even when request startup failed, which is why full RCE was validated there before any application code runs; PHP-FPM exits the child on startup failure, preventing the application-independent path (complete FPM exploitation unproven, though post-startup OOM paths remain theoretically susceptible); FrankenPHP is likely susceptible by analogy to mod_php, and LSAPI is modeled on FPM with only likely, unvalidated application-specific exploits. The fix replaces longjmp() with a delayed graceful soft OOM at the next VM safe point plus an immediate hard OOM via _exit() above a second, higher threshold.
Know when PHP gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Remote, unauthenticated, no interaction (AV:N/PR:N/UI:N); AC:H because reliability depends on build, extensions, frontend and allocator layout with possible multiple attempts; RCE in the worker process yields C:H/I:H/A:H, scope unchanged.
Primary rating from Vendor (vendor:ubuntu).
CVSS VectorVendor: vendor:ubuntu
Lifecycle Timeline
6DescriptionCVE.org
Remote code execution issue
Articles & Coverage 3
Technical POC Analysis
The bug is a use-after-free (CWE-416) in php-src request memory handling.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Latest POC
2 public PoC links from exploitdb, github, nuclei, plus 1 unverified
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
A critical unauthenticated remote code execution vulnerability in PHP versions 8.2 through 8.5 (such as 8.2.x before 8.2.35) allows attackers to compromise web servers running Apache mod_php under default configurations. This puts customer-facing applications and internal systems at risk of full takeover, data theft, and service disruption, demanding immediate leadership action to patch affected environments.
Apply vendor patch.
Threat Model
5 threats: Elevation of Privilege, Denial of Service, Tampering and 2 more
5-step attack chain with trust boundaries and controls
Full threat model - attack chain, trust boundaries, controls per stage and evidence - is part of the Pro and Business plans.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
In PHP versions 7.1.x below 7.1.33, 7.2.x below 7.2.24 and 7.3.x below 7.3.11 in certain configurations of FPM setup it
sapi/cgi/cgi_main.c in PHP before 5.3.12 and 5.4.x before 5.4.2, when configured as a CGI script (aka php-cgi), does not
(1) boardData102.php, (2) boardData103.php, (3) boardDataJP.php, (4) boardDataNA.php, and (5) boardDataWW.php in Netgear
The '/common/download_agent_installer.php' script in the Quest KACE System Management Appliance 8.0.318 is accessible by
ProjectSend versions prior to r1720 are affected by an improper authentication vulnerability. Rated critical severity (C
Roundcube Webmail contains a critical PHP object deserialization vulnerability (CVE-2025-49113, CVSS 9.9) that allows au
Util/PHP/eval-stdin.php in PHPUnit before 4.8.28 and 5.x before 5.6.3 allows remote attackers to execute arbitrary PHP c
Palo Alto Networks PAN-OS management web interface contains an authentication bypass allowing unauthenticated attackers
Nagios XI version xi-5.7.5 is affected by OS command injection. Rated high severity (CVSS 8.8), this vulnerability is re
Nagios XI version xi-5.7.5 is affected by OS command injection. Rated high severity (CVSS 8.8), this vulnerability is re
The get_referers function in /opt/ws/bin/sblistpack in Sophos Web Appliance before 3.7.9.1 and 3.8 before 3.8.1.1 allows
The Backup Migration plugin for WordPress is vulnerable to Remote Code Execution in all versions up to, and including, 1
EUVD-2026-107260
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB
GitHub
VulDB