It hasn’t even been that long since PHP2Shell was disclosed—and now another PHP vulnerability?
A Three-Line Summary for Those in a Hurry
- The PHP development team released a security update on November 19, 2026, that addressed seven critical-level vulnerabilities; no instances of these being exploited in actual attacks have been reported yet.
- Among these, request smuggling in environments that reuse connections between the web server and PHP-FPM, object injection via the session upload feature, and a memory error in PHP 8.5’s magic methods—all of which have been confirmed to lead to remote code execution—are the most critical.
- You should immediately upgrade to PHP 8.5.13, 8.4.28, 8.3.37, or 8.2.36 or higher. For versions 8.1 and below, for which no official patches are available, you should migrate to a supported version. If an immediate upgrade is not possible, you should apply temporary mitigation measures, such as disabling connection reuse and the upload progress feature.
Glossary of Terms for Better Understanding Before Reading
This article frequently uses terminology related to web servers and the internal workings of PHP. Familiarizing yourself with the terms below before reading the main text will make it easier to follow the flow.
- PHP-FPM: A separate program that receives and processes requests from the web server that require PHP code execution. Web servers such as Nginx or Apache communicate with PHP-FPM using a standardized format called FastCGI.
- Worker: A worker is a process that PHP-FPM keeps running in the background; a single worker processes multiple requests sequentially. As a result, traces left by a previous request can affect the next request handled by the same worker.
- Session: A feature that temporarily stores user-specific information on the server, such as login status. Users are assigned a “session ID,” and by default, PHP stores sessions in a file on the server.
- Serialization and Deserialization: Converting data within a program into a format suitable for storage is called serialization; converting that format back into data is called deserialization. The data restored in this process may include not only simple values such as numbers or characters, but also “objects”—entities for which specific code execution occurs when they are created or destroyed. During deserialization of characters created by a threat actor and their revival as objects, this is called object injection.
- Use-After-Free: This is an error where a program accidentally reuses memory that it has released after no longer needing it. If other data is already present in that location, the program may behave erratically or crash; if a threat actor has preemptively placed desired data there, this can lead to code execution.
Overview
At approximately 11:00 p.M. On November 19, 2026 (KST), the PHP development team released security patches for all supported versions. The patched versions are PHP 8.5.13, 8.4.28, 8.3.37, and 8.2.36, and the same fixes are included in version 8.6.0, which was released on the same day. The changelog for PHP 8.5.13 lists a total of 18 CVEs; one of these is a vulnerability in `uriparser`, a URI parsing library bundled with PHP, while the remaining 17 are vulnerabilities in PHP itself. Seven of these were classified as “Critical,” the highest severity rating.
This update follows on the heels of the emergency Vulnerability Patch released a month ago in October to address the PHP2Shell remote code execution vulnerability. Some of the seven vulnerabilities in this update were re-fixed because the previous fixes were incomplete, while others are new issues of the same nature. Most of them require specific configurations or code patterns—rather than the default settings—to be exploited, but some are dangerous enough that, if the conditions are met, a threat actor could perform code execution on the server.
As of November 19, 2026, there have been no reported instances of these vulnerabilities being exploited in actual attacks. They have also not yet been added to the “List of Actively Exploited Vulnerabilities” maintained by the US Cybersecurity and Infrastructure Security Agency (CISA).
This article will discuss seven vulnerabilities classified as “critical.” First, we will explain the causes of vulnerability for each vulnerability. Next, we will outline the conditions under which each vulnerability occurs and what additional resources a threat actor must possess to cause actual damage. Finally, we will introduce patches and temporary mitigation measures.
Causes of Vulnerabilities
The seven vulnerabilities can be broadly categorized into three types based on their causes.
- One issue involving communication between the web server and PHP: a problem where the system incorrectly distinguishes where one request ends and the next begins
- Two cases involving incorrect interpretation of session data: an issue where data injected by a threat actor is converted into a program object during the process of reading stored sessions
- Four cases of reusing memory that has already been released: a memory error known in the security field as “Use-After-Free”
Let’s examine the causes of the vulnerabilities in each category one by one.
CVE-2026-129289: PHP-FPM Request Smuggling
CVE-2026-129289 is a vulnerability caused by PHP-FPM failing to properly clean up leftover data from a previous request, resulting in that leftover data being mistakenly accepted as part of a new request.
To improve performance, a web server can be configured to send multiple requests consecutively over a single connection to PHP-FPM, rather than establishing a new connection for each request; this issue arises in such connection-reuse environments. If a PHP application leaves the channel for reading the request body open without reading it to the end, the remaining portion of the body stays in the connection. If a user deliberately sends a request to upload a file with a malformed format, causing PHP to stop reading in the middle of the body, PHP-FPM—having forgotten how far it had read—will process the remaining portion as if it were a new request arriving over the same connection.
A threat actor exploits this vulnerability by pre-embedding a fake request—formatted as a request—at the end of the body; within this fake request, the threat actor can freely specify which PHP file to execute and how to modify PHP settings. From the web server’s perspective, it has merely processed a single legitimate request, but PHP-FPM ends up executing the request hidden by the threat actor as well. This type of attack, in which one request is secretly embedded within another, is called “Request Smuggling,” and this processing mechanism has existed since 5.6.0.
CVE-2026-115560: Session Serialization Method Mismatch
CVE-2026-115560 is a vulnerability caused by the session storage and reading sides interpreting data differently; this discrepancy allows characters inserted by a threat actor to be utilized as program objects.
PHP converts session data into text and stores it in a storage medium such as a file; there are several serialization methods that follow the rules for this process. The default method concatenates each session entry in the format “name|content,” inserting a vertical bar between the name and the content; when reading, if a vertical bar is encountered, the text up to that point is treated as the name, and the text following it is treated as the content. In contrast, other methods include one that records the number of characters in the name and reads the first that many characters as the name; in this method, even if a vertical bar appears within the name, it is treated simply as one of the characters comprising the name. There is no problem if the same method is used for both writing and reading a session, but issues can arise when multiple applications or multiple PHP-FPM pools share a single session storage. For example, the situation changes if the writer uses the character-count method while the reader uses the default method. This is because the reading side interprets the vertical bar—which was merely part of the name on the writing side—as a marker indicating that “the name ends here and the content begins,” and consequently reads the remaining characters following the vertical bar as session content, i.E., The data to be restored.
Of course, this difference alone is not enough to enable an attack. Since the application typically determines what is stored in a session and under what name, a threat actor has no way to include a vertical bar and the desired characters in the session item’s name. The feature that opens this vulnerability is the one that records file upload progress in the session. This feature stores the progress of the file upload as a new entry in the session, creating the entry name by appending the values contained in the upload request directly to a fixed prefix that signifies “upload progress.” Furthermore, since PHP handles this storage automatically before code execution, even an unauthenticated threat actor can fill the session entry name with arbitrary characters simply by sending a single upload request.
The threat actor appends object data—designed to perform the desired action when restored—to this name, separated by a vertical bar. To the writer, this is just a slightly odd-looking entry name, but the reader interprets the characters following the vertical bar as session content and restores them as-is. As a result, when the session is read, object injection occurs, causing the object designed by the threat actor to be instantiated.
One of the October PHP2Shell vulnerabilities was also related to this upload progress feature. Some security firms refer to the CVE-2026-115560 vulnerability as the “third PHP2Shell” because it represents another Path that the fixes from that time failed to block. However, unlike the two October vulnerabilities—which stemmed from memory corruption caused by abnormal request termination—this vulnerability is fundamentally different in that it involves object injection via deserialization. In other words, while the attack vector and the ultimate damage (remote code execution) are the same, the mechanism by which the problem occurs is different.
CVE-2026-126714: Partially Overwritten Session Files
In some cases, PHP stores session files by overwriting existing content without deleting it. If the overwrite operation is forcibly interrupted, the new and old content become mixed, and this mixed content can be interpreted as a program object. The resulting vulnerability is CVE-2026-126714.
By default, PHP stores sessions in files; if the new data is shorter than the existing file, it first clears the file before writing. However, if the new data is the same length or longer, PHP assumes the new data will overwrite all existing content anyway and overwrites the file starting from the beginning without clearing it first. While this approach usually poses no problem, if the process is forcibly terminated during the overwrite, the file ends up containing a mix of the beginning of the new data and the end of the previous data.
If such a mixed file is read in the next request, the section where the new data and the previous data are concatenated can be interpreted as a serialized object. If a threat actor pre-designs both sets of data, they can create a desired object, which ultimately leads to object injection, as described earlier in CVE-2026-115560. However, unlike CVE-2026-115560, this vulnerability occurs even when both the writer and reader use the same default serialization method.
CVE-2026-129496: Use-After-Free in the Time Zone Cache
The four vulnerabilities introduced below are all “Use-After-Free” vulnerabilities, where issues arise from reusing memory that has already been deallocated.
CVE-2026-129496 is a vulnerability caused by PHP failing to clear the location of time zone information that was briefly used and released when the application started; later, while processing a request, PHP assumes that information is still in that location and reads from memory that has already been released.
PHP stores and reuses time zone information in memory so it does not have to look up new information every time it handles dates and times. However, if a warning message occurs during the PHP process startup and this message is logged to the file-based error log, the time zone information retrieved to generate the timestamp for the log entry is stored in temporary memory used only during the startup phase. This temporary memory is released once startup is complete.
Normally, this isn’t a problem because the reference pointing to the location of the time zone information is cleared during the subsequent initialization process. However, if the warning is logged after that initialization has completed, the reference remains intact. Therefore, not all startup-phase warnings cause problems; only those logged to the file-based error log during the latter part of the startup phase are affected. If a newly spawned worker (process) processes its first request while this reference remains and then logs another warning, it will read from memory that has already been released. These startup-phase warnings typically occur when time zone settings are entered incorrectly or when session settings that are no longer recommended are used.
CVE-2026-129481: Use-After-Free Due to Interruption During Session Termination
CVE-2026-129481 is a vulnerability that occurs when PHP’s session cleanup process is interrupted by an error while processing and concluding a single session-based web request, leaving memory address information that should have been deleted intact. Any request that uses a session—such as when a logged-in user opens a page—undergoes this cleanup process at the end.
When a session begins, PHP records the file name of the currently executing script file in the request memory and stores its location in an internal variable. This internal variable is cleared during the final step of session cleanup after the request ends. However, prior to that, PHP removes the values stored in the session one by one; during this process, code execution occurs for PHP code written by the web service developer—rather than PHP itself—which may be executed. This is because sessions can store not only simple values such as numbers or characters but also objects created by the developer, and these objects are often designed to clean up after themselves when they are destroyed. Since this cleanup code is written by the Service developer, the developer’s code is effectively executed at the moment PHP removes the session values. For example, if a developer has placed a custom file I/O channel in the session, code execution to close that channel will occur at this stage.
If a fatal error occurs in that code that immediately halts execution, the cleanup process is interrupted before internal variables are cleared; meanwhile, the memory allocated for the request is released in its entirety, causing the internal variables to point to memory locations that no longer exist. This incorrect address information is used in the next request processed by the same worker, regardless of whether that request belongs to a different user. This vulnerability is a residual issue resulting from an incomplete fix for CVE-2026-109619, which was discovered in October, and affects PHP 8.3부터.
CVE-2026-129182: Use-After-Free Due to Regeneration of Error Call Path; Affects PHP 8.5 Only
CVE-2026-129182 is a vulnerability that occurred because PHP 8.5did not account for cases where error logs, which are normally cleared at the end of a request, are recreated during the subsequent cleanup process; the recreated logs remain until the next request, pointing to memory that will soon be released.
When an error occurs in a program, a log can be created that traces back the sequence of functions called—which function called which function—up to the point where the error occurred. For example, if an order processing function calls a payment function, which in turn calls a card verification function, and an error occurs there, this sequence is recorded; simply put, this can be viewed as a “call path.” Starting with PHP 8.5, when a fatal error occurs, the call path is logged as well, and it is enabled by default.
Since the call path is generated using request memory, the 8.5.12 patch released in October was designed to clear this path when the request ends. However, the patch overlooked the fact that if a fatal error occurs again during the cleanup phase following the clearing of the path, a new path is generated.
So why might an error occur during the cleanup phase? In addition to server-wide default settings, PHP allows you to apply different settings to specific folders or Paths. When using path-specific settings, PHP changes the configuration only for the duration of requests to that path; once the request ends, it reverts to the server-wide settings for the next request. However, depending on the combination of settings—such as memory limits or output compression—a fatal error can occur during this rollback process. Examples include setting different memory limits for the entire server and a specific path, or enabling output compression server-wide while disabling it for a specific path. The memory allocated due to this error remains pointed to memory intended for the next request—which is about to be released—and is used by the next request processed by the same worker.
CVE-2026-129474: Use-After-Free in Magic Method Error Path, Affects PHP 8.5에만
CVE-2026-129474 is a vulnerability in PHP 8.5 where it occurs when a fatal error happens at the moment a magic method intercepts a call and passes it to the actual processing function; as a result, a value pointing to memory that has already been deallocated is stored in the error log.
Magic methods are special methods that PHP invokes on behalf of the program when a non-existent method is called. For example, even if a logging tool does not have a separate method called “logWarning,” if a program calls it by that name, the magic method can intercept the call and forward it to the function that actually handles the logging. In other words, it acts as an intermediary between the name called by the program and the function that actually performs the task. Therefore, they are frequently used in code that forwards incoming calls to the actual processing logic, such as in logging tools, database libraries, and Laravel’s facade functionality.
If a fatal error occurs during the brief moment when the call is passed via a magic method, the call path described earlier is generated, and it includes the values passed to each function. The problem is that some of the values logged at that exact moment may point to memory locations that have already been released. A threat actor can manipulate the size of the request to cause PHP to exceed its memory limit at precisely this moment, triggering a fatal error. If other data is subsequently written to that freed memory location, PHP will read the log and use the new data instead of the original value; thus, a threat actor can exploit this by injecting arbitrary data into that location.
However, the call path may log only which functions were called, or it may also log the values passed to each function; which option is used is determined by configuration. This vulnerability occurs only when the log is configured to record passed values. This is because if passed values are not logged, the log will not contain any values pointing to the returned memory.
Trigger Conditions and Exploitation Conditions
The mere presence of a vulnerability does not guarantee a successful attack. Here, we will examine this in two stages.
- Trigger Conditions: What server settings, application code, and request sequence must be in place for the bug to actually occur?
- Exploitation Conditions: Once the bug occurs, what else is required for a threat actor to turn it into actual damage, such as code execution?
| CVE | Supported versions for which a fix has been provided | Attack Location | Trigger Conditions | Exploitation Conditions | Maximum Confirmed Damage |
|---|---|---|---|---|---|
| CVE-2026-129289 FPM Request Smuggling | 8.2~8.5 | Remote, no login required | FastCGI connection reuse enabled + application Path that does not read the entire request body + manipulated upload request | Only the path to a single PHP file on the server is required | Remote Code Execution |
| CVE-2026-115560 Session Serialization Mismatch | 8.2~8.5 | Remote | Upload progress feature enabled + Different serialization methods used by parties sharing the session store | Target session ID + gadget chain within the application | Command execution |
| CVE-2026-126714 Partial Overwrite of Session File | 8.2~8.5 | Remote, no login required | File-based sessions enabled + Forced termination of the process while overwriting data that is the same length as or longer than the existing data | Specify session ID + Stop writing at desired point + Mixed data design + Memory corruption flaw in built-in PHP class | Remote Code Execution, as reported by the original researcher |
| CVE-2026-129496 Time Zone Cache UAF | 8.2~8.5 | Remote, limited to process termination | A warning during the latter part of the startup phase is logged in the file error log + Warning occurs on the first request of a new worker | Code execution requires identifying memory addresses + manipulating memory layout + additional configuration depending on the execution environment | Process crash via remote request; code execution achieved in a test environment where memory addresses were known |
| CVE-2026-129481 Session Termination UAF | 8.3~8.5 | Remote; varies depending on the application architecture | A fatal error occurs in code called during session cleanup | The next request must be routed to the same worker | Use-After-Free reproduction; process crash mentioned as a possible impact |
| CVE-2026-129182 Call Path Log Replay UAF | 8.5 | Remote; special configuration required | Failure to restore cleanup phase settings + warning early in the next request; in FPM, configuration is required for the web server to pass PHP settings | The method and conditions for code execution have not been disclosed | Process crash and code execution were not demonstrated |
| CVE-2026-129474 Magic Method UAF | 8.5 | Remote; the demonstrated Path does not require login | Configuration that logs values passed to functions + memory limit exceeded while entering the magic method | Adjusting request size + identifying memory addresses | Remote code execution |
[Table 1] Investigation Details for 7 Critical Vulnerabilities
The second column of the table does not represent the full scope of the vulnerabilities but rather the supported versions for which official fixes were recently released. In many cases, the vulnerabilities themselves have existed for much longer. Since the same behavior was present in CVE-2026-129289 starting with PHP 5.6.0, in CVE-2026-115560 starting with 5.4.0, and in CVE-2026-126714 starting with 4.1.0, even older versions that are no longer supported may be affected. As shown in the table, the severity varies significantly from vulnerability to vulnerability. Each is explained in detail below.
CVE-2026-129289: The Easiest Vulnerability to Exploit, Provided the Configuration is Correct
Trigger Conditions
The web server must be configured to reuse connections with PHP-FPM without closing them. Nginx, Apache, and HAProxy all allow this connection persistence feature to be enabled, and this scenario applies when that feature is active. Additionally, the application must have a path that opens the request body but does not read it to the end, and the threat actor must send a malformed upload request to that path. If the framework leaves the input stream open before routing or authentication, this condition can be met even on pages that do not use the request body. Conversely, typical Nginx and Apache configurations that close the connection after each request are not affected.
Exploitation Conditions
If all of the above conditions are met, the only additional information a threat actor needs is the Path to a single PHP file actually present on the server. If a hidden, fake request is sent to change the PHP configuration and instruct the server to execute the request body as PHP code first, the code contained in the body will be executed as-is. Since there is no need for sophisticated memory manipulation or precise timing, the success rate is very high. Furthermore, this altered configuration may persist for subsequent requests handled by the same worker.
However, this chain of events leading to code execution has only been confirmed in cases where FastCGI connections are reused. LSAPI, which the LiteSpeed web server uses to communicate with PHP, also contains the same flaw: it fails to clean up the remaining body after reading it. However, since LSAPI uses a different communication format than FastCGI, the attack vector is different. To date, only request mixing has been confirmed in LSAPI, and code execution has not been proven.
CVE-2026-115560: A Dangerous Session Vulnerability That Can Be Exploited Even with Common Libraries
Trigger Conditions
The feature that logs the progress of files being uploaded to the session must be enabled, and the writer and reader of the same session must use different serialization methods. This mismatch occurs when an application changes its serialization method immediately before starting a session, or when applications, FPM pools, and virtual hosts—each configured with different serialization methods—share the same session storage folder. Note that simply splitting FPM pools does not automatically split the session storage. This problem does not occur if all components use the same method.
Exploitation Conditions
First, a threat actor must be able to know or specify the ID of the target session. Next, there must be a gadget chain within the application reading the session. A gadget chain is a technique that links together pieces of code that automatically execute when an object is created or destroyed to produce the desired behavior. In fact, command execution was demonstrated using the Guzzle and Monolog libraries, which are frequently installed via Composer, a PHP package manager. Since these libraries are very common, this condition is met more easily than one might think.
CVE-2026-126714: Vulnerability Reported to Allow Remote Code Execution Without Application Code
Trigger Conditions
The file-based method—PHP’s default session storage method—must be used, and the process must be forcibly terminated while overwriting an existing file with data of equal or greater length. A threat actor must be able to manipulate the session contents through features such as file upload progress or long user inputs stored in the session. The serialization methods used for writing and reading do not need to differ.
As a method for forcing the process to terminate, the security advisory cited a scenario in PHP built with multithreading where another thread exceeds the memory limit, causing the entire process to terminate. The researcher who first discovered this vulnerability also reported other methods. By holding multiple requests to upload in queue to fill the web server’s available memory to its limit, a well-timed request caused the worker writing to the session to exceed that limit. The operating system then forcibly terminates that worker to prevent a memory shortage.
Exploitation Conditions
The threat actor must first be able to specify a session ID to which data will be written, and the application must later read from a session with that same session ID. In the researchers’ reproduction of the exploit, they used the “upload in progress” feature while logged out to upload data to a file with a session ID specified by the threat actor; subsequently, when the application initiated a session with that same session ID, the mixed data was read. Additionally, the layout must be designed so that the exact desired object is created when the old and new data are mixed, and the save operation must be made to stop at the desired point.
Even in the researcher’s reproduction, it took approximately 10 attempts to achieve the desired state. The researcher reported demonstrating remote code execution by combining the injected object with a memory corruption vulnerability in a built-in PHP class. Therefore, the attack is possible even if the application lacks a gadget chain. However, the details of the built-in class used in the combination and its vulnerability have not been disclosed, so external verification is not possible. The security advisory describes this mechanism and lists remote code execution as the impact.
CVE-2026-129496: A Vulnerability Where Process Termination is Easy but Code Execution is Difficult
Trigger Conditions
In a typical single-threaded PHP build, a startup-phase warning must be logged to PHP’s file-based error log. This warning must be logged after the initialization that clears the timezone reference—that is, during the latter part of the startup phase. Cases where the warning is logged only to PHP-FPM’s own log do not qualify. In that state, before a newly spawned worker completes its first request, a request that triggers a warning early in the request process must arrive. A typical example is a request that exceeds the upper limit on the number of input variables that can be contained in a single request. Since workers are spawned or restarted each time, such opportunities arise repeatedly.
Exploitation Conditions
The scope of proven damage from this vulnerability should be considered in two parts.
First, stopping a worker is possible based solely on the conditions described above. The security advisory confirmed that, in a PHP-FPM instance meeting these conditions—with both the input variable limit and Nginx’s header size limit set to their default values—a single maliciously crafted remote HTTP request caused the worker to stop.
Second, code execution was demonstrated in a test environment where the threat actor already knew the server’s memory addresses. To achieve code execution, the threat actor must know the memory addresses and arrange the memory layout as desired; additionally, the required configuration varies depending on the execution environment. The method reported for PHP-FPM requires configuring the system to pre-generate request parameters at the start of the request rather than when they are needed, as well as allowing cookie values to be included in the request parameters; it also requires allowing authentication headers larger than the default limit. Another method reported for Apache mod_php does not require changing these settings but instead requires allowing requests that transfer large amounts of data exceeding the memory limit and accepting large authentication headers. Operating systems have a protection mechanism that randomly changes memory addresses each time a program runs, making it difficult for threat actors to predict those addresses; however, no method for remotely bypassing this protection has yet been demonstrated.
CVE-2026-129481: Vulnerability in Application Code Patterns
Trigger Conditions
A fatal error must occur in application code called during session cleanup. The demonstrated environment was PHP-FPM with the OPcache feature—which pre-compiles PHP code and stores it in memory—disabled, and the error occurred in the close function of a stream object stored in the session. If the file name of the script in question is stored in memory—where OPcache retains it for an extended period—it can bypass the Path by which memory allocated for the request is released. However, since uncached scripts can still be executed even when OPcache is enabled, it cannot be concluded that this vulnerability does not exist simply because OPcache is enabled. The security advisory also explains that OPcache alone cannot serve as a reliable countermeasure.
Exploitation Conditions
Subsequent requests must be routed to the same worker. The security advisory confirmed, through reproduction testing, only the phenomenon of reusing memory that had already been released. The worker freezing was described as a potential consequence of this, but no code execution demonstration was mentioned.
CVE-2026-129182: Vulnerability Requiring a Specific Configuration Combination
Trigger Conditions
Two steps are required. First, a fatal error must occur while the settings are being restored to their original state at the end of a request. For example, this could happen if memory limit settings are configured differently for the entire server and for a specific path, or if output compression is enabled for the entire server but disabled for a specific path while a separate output handling function is specified for that path. Second, a warning must be triggered before the next request for the same worker is initialized. In Apache mod_php, this condition can arise due to directory-specific settings, but in PHP-FPM, it only applies when the web server is configured to pass PHP configuration values along with each request and those values trigger a warning. Since the bug requires the specific combination of settings described above to already exist on the server, it is unlikely to occur in typical configurations.
Exploitation Conditions
So far, the confirmed effects of this bug range from memory errors to process crashes. Although security advisories, such as CVE-2026-109619 from October, suggest it could lead to remote code execution, no code execution has been demonstrated using this vulnerability as an entry point, nor have the additional conditions required for such an exploit been disclosed.
CVE-2026-129474: Vulnerability in PHP 8.5 Confirmed to Allow Remote Code Execution
Trigger Conditions
Call trace logging must be enabled in PHP 8.5; this feature is enabled by default. Additionally, call trace logging must be configured to log the values passed to functions. While PHP’s default setting logs passed values, the configuration file recommended by PHP for production environments is set not to log them. The application must be structured to pass calls via magic methods, and a fatal error must occur at that moment. In the demonstration, a request was sent to a page that receives JSON data and logs it via magic methods, with the request size adjusted so that the memory limit would be exceeded the moment the value to be logged was generated.
Exploitation Conditions
A threat actor must be able to manipulate memory usage patterns via request data and secure a memory address that can be written to even in environments where memory address randomization protection, as described earlier, is enabled. If the attempt fails, the worker will stop, or the request will terminate with a standard resource limit error. There is no need to upload a PHP file or specify a method name. The security advisory stated that remote code execution was confirmed in PHP 8.5 using this method. The fact that the attack could be carried out without logging in was specific to the path used in the demonstration; whether login is required may vary depending on the application path. Although Laravel’s facade functionality and some features of Magento were mentioned as relevant paths, it has not been proven that actual attacks are possible.
Mitigation Measures
1. Patch
The most reliable countermeasure is to upgrade to the latest version compatible with your current installation. This patch includes fundamental fixes for all seven vulnerabilities; the versions to upgrade to, depending on your branch, are listed in the table below.
| Current Version | Target Upgrade |
|---|---|
| PHP 8.5.x | 8.5.13 or later |
| PHP 8.4.x | 8.4.28 or later |
| PHP 8.3.x | 8.3.37 or later |
| PHP 8.2.x | 8.2.36 or later |
| PHP 8.1 or earlier | No official patch → Must upgrade to a supported version |
[Table 2] Upgrade versions corresponding to the version series currently in use
As shown in the table, no official patches are provided for PHP 8.1 and earlier versions. As explained earlier, some vulnerabilities exist even in older versions, so if you are using one of these versions, there is no fundamental solution other than migrating to a supported version series. Even if you are currently using 8.2, it is too early to rest easy. Since security support for PHP 8.2 is scheduled to end on December 31, 2026, even if you upgrade to 8.2.36 now, it’s a good idea to also make plans to migrate to a newer version series.
During the upgrade process, you must also verify that the patches have actually been applied. Linux distributions such as Ubuntu and RHEL sometimes apply security fixes without changing the version number; this is known as a backport. Therefore, if you are using distribution packages, do not make assumptions based solely on the version number; instead, check the distribution’s security bulletins to confirm whether the relevant CVE has been fixed. If you’re running in a container environment like Docker, you’ll need to download a new base image and rebuild it for the patch to take effect. In any case, after completing the upgrade, you must restart the PHP-FPM master process and all workers—or Apache—for the new version to take effect.
However, CVE-2026-115560 cannot be resolved by the patch alone. The patch changes the default setting for the upload progress feature to “off,” but if an administrator re-enables this feature and different serialization methods are used to share the same session store, the same inconsistency may still occur. Therefore, even after applying the patch, you must also verify the session settings as described in the mitigation steps below.
2. Mitigation Methods
If upgrading immediately is difficult, you can reduce the risk by changing the settings. However, this is a temporary measure to hold off until the patch is available. Additionally, the method of application varies depending on where the changed settings are located. If you have changed PHP settings, you must restart PHP-FPM or Apache (if using mod_php); if you have changed the settings of a web server such as nginx or Apache, you must reload the configuration so that the web server can read the new settings. Below, we describe mitigation methods for each vulnerability, following the order discussed earlier.
1) Disable Connection Reuse Between the Web Server and PHP-FPM
First, the PHP-FPM request smurfing vulnerability (CVE-2026-129289) can be prevented by ensuring the web server does not reuse connections with PHP-FPM. In nginx, disable `fastcgi_keep_conn`, and in Apache, disable `enablereuse` to ensure the connection is closed after each request. Since these are web server settings—not PHP settings—you must reapply the nginx or Apache configuration after making these changes. Since connection reuse is enabled by default in some container images, if you are running the application in a container, it is advisable to check the settings within the image directly. Additionally, you should verify that the port on which PHP-FPM listens for requests is not exposed to the outside or to untrusted networks.
2) Disable the Session Upload Progress Feature
The session-related vulnerabilities CVE-2026-115560 and CVE-2026-126714 both use the upload progress Path as an attack path. Therefore, if you do not use this feature, you should disable it by setting `session.upload_progress.enabled=0` as a priority to prevent unauthenticated threat actors from writing data to the session. Since changing this via `ini_set()` within the code is already too late, you must modify it in `php.ini`, the FPM pool configuration, or the virtual host configuration.
3) Standardizing Session Serialization Methods and Inspecting Session Storage
In addition to this common measure, each of these two session vulnerabilities requires a different response. Since CVE-2026-115560 arises from a mismatch in serialization methods, you must either set the `session.serialize_handler` value to the same value for all applications sharing the session store or completely separate the stores. As explained earlier, this measure remains necessary even after applying the patch if the upload progress feature has been manually enabled. In contrast, CVE-2026-126714 can occur even when the serialization method is the same, so standardizing the method alone is not sufficient to prevent it. To address this vulnerability, it is best to minimize the amount of user input stored in sessions and, whenever possible, use a session store that replaces the entire record when saving.
4) Summary of PHP Startup Phase Warnings
CVE-2026-129496, a timezone cache vulnerability, occurs when startup warnings are logged to the error log; therefore, the most direct countermeasure is to eliminate those warnings. Clear all warnings logged in the error log during PHP startup—such as incorrectly set `date.timezone` values or deprecated session settings—and then restart the server. If it is difficult to eliminate all warnings immediately, you can also configure the system to send the error log to `syslog` instead of a file.
5) Check for Critical Errors During Session Cleanup
Since the session termination vulnerability CVE-2026-129481 originates from critical errors in the application code, you must verify that no critical errors occur in code called during session cleanup—such as functions that close streams. As a quick fix, you can set `pm.max_requests=1` in PHP-FPM to launch a new worker for each request. This is because the worker will be terminated before any invalid references are passed on to the next request. However, this method results in significant performance degradation.
6) Disabling Call Stack Tracing for Fatal Errors in PHP8.5
Since CVE-2026-129182 and CVE-2026-129474, both specific to PHP 8.5, stem from the Path of fatal error call traces. Therefore, you can prevent both vulnerabilities by changing the setting to `fatal_error_backtraces = 0` in the administrator-level configuration to disable this logging entirely and then restarting all workers. This is also the temporary mitigation method recommended in the security advisory for CVE-2026-129182, and you must ensure that this feature is not re-enabled via request-level settings.
7) Excluding Values Passed to Functions from Logging
In environments where call trace logging cannot be disabled, a workaround specific to CVE-2026-129474 is to set `zend.exception_ignore_args` to `On` to prevent values passed to functions from being logged. However, changing this setting only for command execution will not be effective; you must also verify the FPM pool configuration. However, since this setting only excludes passed values from the logs and does not prevent call stack logging itself, it does not serve as a mitigation for CVE-2026-129182. Additionally, note that simply setting `display_errors=0` to prevent errors from being displayed on the screen is not sufficient to prevent either vulnerability.
Conclusion
Although the seven critical vulnerabilities fixed in this PHP security update were all classified as “critical,” their actual risk levels vary significantly.
The first vulnerability to examine is CVE-2026-129289, a PHP-FPM request smurfing vulnerability. This is because, if a web server is configured to reuse connections with PHP-FPM and the application contains a path that does not read the entire request body, a threat actor can perform remote code execution with a single manipulated upload request without needing to manipulate memory. CVE-2026-115560, a session serialization mismatch vulnerability, also warrants immediate attention. Since command execution has been demonstrated using common libraries such as Guzzle and Monolog, you must verify whether your application uses functionality for uploading files and whether session storage is shared. If you are running PHP 8.5, you should also prioritize CVE-2026-129474, a magic method vulnerability where remote code execution has been confirmed.
The researcher also reported that CVE-2026-126714, a session file overwrite vulnerability, allowed for remote code execution without an application gadget chain. However, multiple attempts are required to force the process to terminate at the desired time, and the details of the built-in class flaw used in the attack have not yet been disclosed. The remaining vulnerabilities require complex configuration combinations or the discovery of memory addresses to achieve code execution, making them relatively difficult to exploit. However, as seen in the case where the October patch was incomplete and had to be fixed again just one month later, similar issues may continue to emerge.
Therefore, the best course of action is simple: upgrade to the latest version immediately, and until then, apply the mitigation settings listed above. We also recommend taking this opportunity to review settings you might not normally pay attention to, such as FastCGI connection settings, session storage configuration, and startup warnings.
Source
- Official PHP ChangeLog: https://www.php.net/ChangeLog-8.php
- Php-src Security Notice, GitHub Security Advisories: https://github.com/php/php-src/security/advisories
- GHSA-qc49-hpvq-g2w6: CVE-2026-129289
- GHSA-658j-r8rw-q6mx: CVE-2026-115560
- GHSA-fm2m-fjf5-v3cp: CVE-2026-126714
- GHSA-gr4f-wgx5-jpfv: CVE-2026-129496
- GHSA-g3vh-838c-65v7: CVE-2026-129481
- GHSA-2fjv-p558-g82m: CVE-2026-129182
- GHSA-8mjj-2r7p-4hg2: CVE-2026-129474
- Php[architect], “PHP’s November security release: seven critical fixes, explained” : PHP Security Release Fixes Seven Critical Vulnerabilities | Exploitr
- Depthfirst, Original research on CVE-2026-126714: https://depthfirst.com/research/phpaftershell
- PHP 8.5.12 session file storage code: https://github.com/php/php-src/blob/php-8.5.12/ext/session/mod_files.c