TL;DR
- What happened: The PHP project issued emergency security updates addressing two critical pre-authentication remote code execution (RCE) flaws, CVE-2026-109618 and CVE-2026-109619, followed by a third edge-case flaw, CVE-2026-115560.
- Who is affected: Systems running PHP 8.5 prior to 8.5.12, 8.4 prior to 8.4.27, 8.3 prior to 8.3.36, and 8.2 prior to 8.2.35. All end-of-life (EOL) releases (including 7.4, 8.0, and 8.1) lack active binary maintenance and are vulnerable.
- Impact: Both primary flaws carry a CVSS score of 9.2. Unauthenticated remote attackers can execute arbitrary code with web server process privileges before any userland application logic or authentication code executes.
- Remediation: Immediately upgrade to PHP 8.5.12, 8.4.27, 8.3.36, or 8.2.35. Where immediate binary deployment is delayed, enforce temporary runtime workarounds including
php_admin_value memory_limit -1and disablingsession.upload_progress.enabled.
On 20 October 2026, the PHP project announced emergency security releases to address severe pre-authentication php rce vulnerabilities within core engine request handling routines. Upstream patches were released on 21 October 2026 at 13:30 UTC, providing updated binaries across active release branches: PHP 8.5.12, 8.4.27, 8.3.36, and 8.2.35. Because the memory corruption flaws trigger during early request initialisation, an unauthenticated remote attacker can achieve arbitrary code execution prior to the execution of any userland application code or authentication logic.
The release addresses two primary vulnerabilities carrying CVSS scores of 9.2: CVE-2026-109618 (GHSA-w8hw-w9fx-j79w), an out-of-memory error handling memory corruption flaw, and CVE-2026-109619 (GHSA-6wmf-4rv5-p3rp), a cross-request global state persistence issue. On 23 October 2026, the PHP project disclosed a third RCE vulnerability, CVE-2026-115560, which impacts unusual web server configurations and will not receive an out-of-band binary patch. Public proof-of-concept exploits have begun circulating, significantly elevating the immediate operational threat for internet-facing installations.
Every major PHP execution architecture is exposed, including PHP-FPM, Apache mod_php, php-cgi, FrankenPHP, and LiteSpeed, with Apache mod_php assessed as carrying the highest risk profile. This technical analysis details the Zend Engine internals behind these vulnerabilities, evaluates SAPI-specific attack surfaces, provides operational remediation steps, and outlines defensive engine configurations for environments where binary updates cannot be immediately deployed.
Executive Overview: Dual Critical RCE Flaws in Core PHP
The security patches published on 21 October 2026 resolve fundamental memory handling defects within the Zend Engine runtime. In PHP request architectures, incoming HTTP requests transition from the Server Application Programming Interface (SAPI) layer directly into the engine’s early request initialisation routines before script interpretation begins. During this bootstrap phase, the engine allocates internal data structures, parses HTTP headers, decodes multipart form data, and establishes execution contexts.
The two main vulnerabilities fixed in the 21 October 2026 emergency update (according to CERT-EU Advisory 2026-018) exploit gaps in how the Zend Engine manages memory during unexpected execution halts during request setup:
- CVE-2026-109618 (CVSS 9.2): A memory corruption flaw caused by improper out-of-memory (OOM) handling. When an allocation request breaches the engine memory threshold during initialisation, non-local jump mechanisms (
longjmp()) abort request processing. Subsequent cleanup routines attempt to free partially initialised pointers that contain uninitialised data, leading to controllable heap corruption. - CVE-2026-109619 (CVSS 9.2): A global state persistence flaw where internal request structures persist in worker memory after fatal errors or execution timeouts. When the backing memory of those structures is freed, lingering pointers remain accessible to subsequent HTTP requests handled by the same worker process before reset logic executes.
On 23 October 2026, the PHP project disclosed a third flaw, CVE-2026-115560. Assessed by upstream maintainers as an edge-case vulnerability affecting atypical application deployments, this issue will not receive an out-of-band emergency release. Operators can mitigate CVE-2026-115560 using specific configuration directives while awaiting scheduled upstream releases.
Because these vulnerabilities trigger within low-level engine initialisation routines, application-level security mechanisms—such as web application firewall (WAF) script filters, framework middleware, parameter sanitisation, or user authentication checks—cannot prevent exploitation. The engine fails before userland code receives execution control.
Breakdown of CVE-2026-109618: OOM Handling and Memory Corruption
Understanding CVE-2026-109618 requires examining how the Zend Engine handles memory allocation limits (zend_mm) and abrupt error unwinding. PHP enforces its configurable memory_limit directive inside its internal heap allocator. When a heap allocation pushes total request allocation past the configured threshold, the allocator raises an OOM error and halts standard control flow using C standard library non-local jumps: setjmp() and longjmp().
+-----------------------------------------------------------------------+
| Incoming HTTP Request |
| (e.g. Multipart File Upload with large headers) |
+-----------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------+
| Zend Engine Early Request Initialisation |
| Allocates internal request buffers & structure tables |
+-----------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------+
| Allocation Exceeds memory_limit |
| zend_mm triggers longjmp() to abort |
+-----------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------+
| php_request_shutdown() Execution |
| Engine attempts cleanup of partially initialised request structures |
| Uninitialised pointers read as valid heap allocation headers |
+-----------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------+
| Heap Corruption / Arbitrary Execution |
| Engine frees memory addresses matching attacker-primed heap data |
+-----------------------------------------------------------------------+
Under standard operating conditions, longjmp() bypasses function return chains and transfers execution directly to the request shutdown handler (php_request_shutdown()). However, when an allocation failure occurs during early request processing—such as parsing complex form-based multipart file uploads—the request structure is left only partially populated.
When the engine invokes php_request_shutdown(), the cleanup logic iterates over request structures to deallocate memory slots. Because longjmp() interrupted initialisation halfway through, specific pointer fields inside internal request tables contain uninitialised data from previous worker allocations rather than valid memory references.
An attacker can send a sequence of HTTP requests designed to groom the process heap, populating unused allocation slots with controlled memory addresses. By following with a multipart upload request crafted to breach memory_limit during header parsing, the cleanup sequence executes efree() operations on attacker-controlled addresses. This grants a write-anything-anywhere primitive, enabling control-flow redirection and arbitrary remote code execution.
Breakdown of CVE-2026-109619: Stale Global State Across Worker Requests
High-performance web server environments rely on persistent worker process architectures to handle high request volumes without the overhead of per-request process creation. In PHP-FPM, Apache worker MPM, and modern SAPI implementations like FrankenPHP, a worker process processes hundreds or thousands of sequential HTTP requests across its lifecycle. To isolate request contexts, the Zend Engine relies on a formal request lifecycle: request initialisation (RINIT), execution, and request shutdown (RSHUTDOWN).
CVE-2026-109619 arises from a failure in state management during the RSHUTDOWN sequence following an unhandled fatal error, timeout, or interrupted upload parser. Internal state pointers owned by global engine modules persist in worker process memory after the backing heap allocations for those objects have been freed by the system allocator.
[ Request N ] ---> Fatal Error / Timeout ---> RSHUTDOWN Frees Backing Memory
|
v
Global State Pointers Retained
|
v
[ Request N+1 ] -> Reads Stale Global Pointers ---> Memory Misinterpretation ---> Pre-Auth RCE
When the same worker process receives a subsequent HTTP request (Request N+1), the engine begins parsing incoming parameters and headers. Prior to the standard RINIT sequence that cleans global variables, subsystem routines (such as session upload progress trackers or diagnostic error routines) access the stale global pointers retained from Request N.
Because the memory backing these pointers was deallocated during Request N shutdown, the worker engine evaluates stale or re-allocated heap contents as live execution objects. An attacker can exploit this by submitting a request that forces a fatal error or execution timeout while writing specific binary payloads into global memory buffers. The subsequent request assigned to that worker process interprets the lingering byte patterns as valid structure addresses or function jump tables, granting unauthenticated code execution within the worker process.
Runtime Engine Blast Radius: FPM, mod_php, FrankenPHP, and LiteSpeed
The operational impact of CVE-2026-109618 and CVE-2026-109619 varies depending on the active SAPI deployment model and process boundary configurations. While all SAPI layers processing untrusted web traffic are vulnerable, differences in process isolation alter memory grooming predictability and overall risk.
| SAPI Architecture | Assessed Risk | Worker Process Model | Primary Attack Vectors |
|---|---|---|---|
| Apache mod_php | Highest | Shared process address space (pre-fork or worker MPM) | Unsegmented process heap, controllable memory layout, persistent global state |
| PHP-FPM | High | Persistent pool workers (dynamic, ondemand, static) | Cross-request worker contamination, predictable heap grooming across requests |
| FrankenPHP | High | Go-managed persistent CGO worker threads | Thread-level heap corruption, stale pointer re-use across HTTP threads |
| LiteSpeed / LSAPI | High | Persistent application worker processes | Multipart upload OOM unwinding, lingering global module state |
| php-cgi | Medium-High | Per-request process spawn or FastCGI worker mode | Single-request OOM memory corruption (CVE-2026-109618 primary risk) |
The core PHP team designated Apache mod_php as the highest-risk runtime model. Under mod_php, the PHP interpreter runs directly within Apache web server processes. The absence of process boundaries between HTTP request decoding and interpreter execution, combined with shared address spaces across requests, makes heap layout manipulation highly deterministic for remote attackers.
PHP-FPM, FrankenPHP, and LiteSpeed implementations are also severely exposed. Production environments typically configure PHP-FPM pools with high worker request limits (such as pm.max_requests = 1000 or higher) to minimize process recycling overhead. This longevity allows attackers to send multiple priming requests to a specific worker process to establish desired heap conditions before triggering the final execution payload.
In addition to web application servers, enterprise platforms that embed PHP internally—such as storage appliances, virtualization consoles, and network management tools—are vulnerable. Engineers must audit internal control planes and management interfaces to ensure underlying runtime binaries are updated.
Analysis of CVE-2026-115560 and Minor Edge-Case Risk
On 23 October 2026, the PHP project disclosed a third vulnerability tracked as CVE-2026-115560. Unlike the dual critical vulnerabilities patched on 21 October, CVE-2026-115560 affects specific, non-standard application configurations. Due to its limited surface area, the PHP maintainers decided against issuing an out-of-band binary patch release.
Full advisory details and code-level root-cause analysis for CVE-2026-115560 remain restricted by the PHP security team, with complete information scheduled for release alongside regular maintenance updates across active release branches. For additional technical background on upstream upload handling vulnerability disclosures, see our analysis of PHP critical RCE patch CVE-2026-115560 details.
Despite the absence of an immediate binary update, upstream maintainers confirmed that disabling session upload progress tracking neutralises the known attack vectors for CVE-2026-115560. System administrators who apply the engine hardening controls detailed in the next section can secure their environments against CVE-2026-115560 while waiting for standard package updates from OS vendors.
Engine Configuration & Defensive Hardening Code Snippets
Where immediate binary package installation is delayed due to change-management windows or vendor repository lag, platform engineers can apply temporary configuration controls. These workarounds disable vulnerable upload progress tracking and eliminate script-driven OOM execution halts.
Configuration Workarounds Are Temporary Mitigations
The configuration directives below remove confirmed attack triggers, such as session upload progress state manipulation and userland memory limit crashes. However, an underlying allocation failure caused by severe server memory exhaustion can still reach vulnerable code paths inside unpatched binaries. Upgrading to patched PHP binaries remains mandatory for complete protection.
1. Mitigating OOM Corruption via php_admin_value
CVE-2026-109618 requires an allocation failure that triggers longjmp() unwinding when PHP’s memory_limit is reached. Setting memory_limit = -1 prevents the Zend Engine from enforcing script-level memory allocations and raising internal OOM halts. This directive must be set via php_admin_value in FPM pool configs or Apache virtual hosts to prevent application userland scripts or local .user.ini files from overriding it.
# /etc/php/8.3/fpm/pool.d/www.conf
[www]
; Disable Zend Engine script memory limits to prevent longjmp() OOM unwinding
php_admin_value[memory_limit] = -1
; Restrict maximum POST size and file upload bounds to reasonable limits
php_admin_value[post_max_size] = 16M
php_admin_value[upload_max_filesize] = 8M
; Enforce periodic worker recycling to destroy accumulated process state
pm.max_requests = 500
Enforcing OS-Level Memory Controls
When setting memory_limit = -1 in PHP configuration, memory boundaries must be enforced at the container or operating system level using cgroups or systemd directives. Do NOT enforce limits using POSIX resource boundaries like RLIMIT_AS or RLIMIT_DATA in limits.conf. System-level allocation calls (such as mmap or brk) returning NULL under POSIX limits re-trigger the exact allocation failure and vulnerable longjmp() unwinding path inside the Zend allocator.
2. Disabling Session Upload Progress and Engine Backtraces
To block stale global state manipulation (CVE-2026-109619) and protect against CVE-2026-115560, disable session upload progress parsing across all worker configurations. On nodes running PHP 8.5, turn off fatal error backtraces.
# /etc/php/8.3/fpm/php.ini or global configuration file
[PHP]
; Disable session upload progress tracking to remove global state persistence vectors
session.upload_progress.enabled = 0
session.upload_progress.cleanup = 1
; PHP 8.5 specific setting: disable engine fatal error backtrace generation
; fatal_error_backtraces = 0
After updating pool files or master configuration files, test the configuration syntax and restart the worker pool service to clear existing process memory spaces:
# Validate configuration syntax prior to restart (test in staging first)
sudo php-fpm8.3 -t
# Perform full service restart to terminate all active worker process address spaces
sudo systemctl restart php8.3-fpm
3. Container Cgroup Limit Enforcement
Use Docker runtime flags or systemd service units to enforce hard memory limits that terminate failing processes via kernel OOM mechanisms rather than interpreter unwinding:
# Example systemd drop-in file (/etc/systemd/system/php8.3-fpm.service.d/override.conf)
[Service]
# Hard memory limit enforced directly by Linux kernel cgroup controller
MemoryMax=2G
MemoryHigh=1.8G
# Terminate worker process immediately upon cgroup boundary breach
OOMPolicy=kill
Operational Remediation Playbook: Upgrades and Repository Guidance
Remediating enterprise web fleets requires coordinating binary upgrades across Linux distribution channels, third-party repositories, and legacy end-of-life installations.
Package Availability and Third-Party Repository Delays
Official Linux distribution maintainers (including Ubuntu LTS, Debian, and Red Hat Enterprise Linux) received advance notification under embargo and published patched packages on 21 October 2026. Systems configured to use official vendor repositories can upgrade using standard package management tools.
However, administrators using volunteer-maintained third-party repositories—notably rpms.remirepo.net (Remi’s RPM repository for Enterprise Linux)—must account for build delays. Third-party volunteer repositories do not receive embargoed access and typically lack updated packages on release day. Environments relying on Remi repository builds should not wait for package publication during an active threat window; operators should temporarily switch to distribution packages, compile updated source binaries, or apply temporary configuration workarounds immediately.
# Debian / Ubuntu package update sequence
sudo apt-get update && sudo apt-get install --only-upgrade php8.3 php8.3-fpm php8.3-cli
# Confirm installed binary version (must be >= 8.3.36 for 8.3 release train)
php -v
Addressing End-of-Life (EOL) PHP Installations
PHP versions 7.4, 8.0, and 8.1 are end-of-life and receive no automated binary package updates from the upstream PHP project. Due to the high severity of these flaws, the PHP security team published minimal source backports for PHP 7.4, 8.0, and 8.1 on official code repositories for teams that compile software internally.
# Source build workflow for applying official minimal backports on legacy EOL builds
# Note: Always execute compilation in isolated build containers
tar -xvf php-8.1.30.tar.gz
cd php-8.1.30/
patch -p1 < /path/to/upstream-cve-2026-109618-backport.patch
patch -p1 < /path/to/upstream-cve-2026-109619-backport.patch
./configure --prefix=/opt/php-8.1-patched --enable-fpm
make -j$(nproc)
sudo make install
If compiling custom binaries or obtaining vendor LTS support is not feasible for legacy systems, isolate unpatched workloads behind strict network access control lists (ACLs) or reverse proxies while preparing migration plans to active release branches (PHP 8.2+). For broader perspective on how modern automated discovery techniques affect legacy platform codebases, see our analysis of AI vulnerability discovery impacts on legacy software stacks.
Key Takeaways and Architectural Implications
The disclosure of CVE-2026-109618, CVE-2026-109619, and CVE-2026-115560 highlights structural security challenges in persistent runtime interpreters using shared worker memory models. When low-level mechanisms like longjmp() interrupt execution during request bootstrap phases, assumptions regarding heap cleanup and global variable cleanup break down.
To strengthen application infrastructure against runtime engine memory corruption risks, platform engineers should adopt three core defensive strategies:
- Frequent Worker Process Recycling: Reduce worker process lifespans (such as setting
pm.max_requests = 500in PHP-FPM) to force process restarts, clearing persistent memory structures and complicating multi-request heap grooming attacks. - Kernel-Level Resource Control: Decouple application memory bounds from interpreter-level controls. Avoid POSIX resource limits (
RLIMIT_AS) inside web execution pools; rely on Linux cgroup limits to terminate over-budget processes cleanly at the OS layer. - Administrative Parameter Precedence: Enforce critical security settings using administrative overrides (
php_admin_value) to prevent userland code, frameworks, or local.user.inifiles from overriding platform-level security directives.
Frequently asked questions
Why is mod_php considered higher risk than PHP-FPM for CVE-2026-109618 and CVE-2026-109619?
Apache mod_php executes the PHP interpreter directly inside main web server worker processes. Because Apache workers share an unsegmented address space across multiple requests and threads, heap layout predictability is significantly higher. This makes memory grooming and stale global state exploitation much easier for attackers compared to isolated PHP-FPM worker pools.
Can web application firewall (WAF) rules fully protect against these vulnerabilities without upgrading PHP?
No. WAF rules can filter known malicious payload signatures or restrict large multipart file uploads at the HTTP edge, but they cannot account for all permutations of memory grooming payloads or aborted execution paths. Because the vulnerabilities trigger during low-level engine request parsing, upgrading to patched PHP binaries remains the only complete defense.
Why shouldn’t I set Linux resource limits like RLIMIT_AS to prevent OOM memory corruption?
Setting RLIMIT_AS or RLIMIT_DATA causes system-level memory allocation functions like mmap() or malloc() to fail and return NULL when the limit is hit. In PHP, this triggers the exact same internal allocation failure and longjmp() request abort logic that causes the CVE-2026-109618 memory corruption vulnerability. Use cgroups or container memory limits instead.
How do I secure end-of-life PHP versions like 7.4 or 8.1 if no official distribution update is available?
Official binary packages are not provided for EOL versions. You must either apply the minimal source backports released by the PHP security team and build binaries from source, contract a commercial LTS vendor that provides backported patches, or enforce strict runtime mitigations like setting memory_limit = -1 and disabling session.upload_progress.enabled.
What is the risk associated with relying on third-party RPM repositories like Remi for emergency security updates?
Third-party volunteer repositories like rpms.remirepo.net do not receive advance embargoed access to security patches. Consequently, updated RPM packages are not available on the official release day. Platforms relying on these repositories face an unpatched exposure window and must manually compile from source or apply temporary runtime configuration workarounds.
Sources and further reading
- Critical Vulnerabilities in PHP (CERT-EU Advisories)
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.