
Web & Cybersecurity · PHP Maintenance
PHP released new security patches on November 19. Patched versions, PHP-FPM and session exploitation conditions, WordPress/Symfony checks, and update procedures.
On November 19, 2026, the PHP project released several security updates fixing vulnerabilities in PHP-FPM, sessions, PHP-CGI, and other engine components. Some could lead to remote code execution, but only when the technical conditions described in the advisories are met. For a WordPress site, a Symfony project, or a PHP SaaS, the priority is to identify the runtime actually in use and apply the appropriate patch.
The versions to note are PHP 8.2.36, 8.3.37, 8.4.28, and 8.5.13. They address a new set of vulnerabilities, distinct from the PHP2Shell flaws disclosed in October and already covered by SDX. AWS lists 17 issues fixed in the November 19 releases, while the Red Hat bulletin analyzes seven of the most serious. The exact number of relevant issues depends on the branch, compiled extensions, and server settings.
Here are the versions and configurations to check, the exploitation conditions for the main CVEs, and an update procedure that avoids confusing php -v in a terminal with the version used to serve web requests.
All four PHP branches, from 8.2 through 8.5, have received a patched release. The most serious scenarios are not automatically exploitable on every site: several require reused FastCGI connections, a particular session storage setup, or an uncommon sequence of events. However, a configuration not exposed to one of these scenarios is no reason to skip the update, which also fixes other vulnerabilities.
The PHP project announced the following security releases on November 18–19, 2026, grouped in the November 19 announcement. For installations using the official PHP archives, these are the minimum versions to target on each affected branch.
| Branch | Patched version | Status as of November 20, 2026 |
|---|---|---|
| PHP 8.2 | 8.2.36 | Security support until December 31, 2026 |
| PHP 8.3 | 8.3.37 | Maintained branch; security patch available |
| PHP 8.4 | 8.4.28 | Maintained branch; security patch available |
| PHP 8.5 | 8.5.13 | Maintained branch; security patch available |
What about PHP 8.6? Its first stable release, 8.6.0, came out on November 19, 2026. It is a new language branch, not a routine patch update that should be applied without compatibility testing. If your project runs on 8.4 or 8.5, it is more prudent to install the patch for that branch immediately, then prepare a separate major-version migration to 8.6.
On some enterprise distributions, including Red Hat, security fixes are backported to packages that retain an older displayed PHP version. In that case, check the vendor's security advisory and the installed package version rather than making a naive comparison with PHP.net. Conversely, retaining an older version without evidence of a backport is not enough to conclude that the server is patched.
These issues primarily affect the PHP runtime and some of its components, not a particular WordPress plugin or framework. A WordPress, Symfony, Laravel, or custom application may therefore be affected if it uses a vulnerable branch and component under the specified configuration conditions.
Check your hosting provider's dashboard and ask when PHP patches are deployed. Updating WordPress or Composer does not replace updating PHP itself.
Inventory PHP-FPM services, PHP-CGI, CLI workers, Docker images, and scheduled tasks. Apply the patched packages or images, then restart the relevant processes.
For a site that relies on a managed platform, the necessary action may be limited to requesting confirmation that the patch has been applied and testing the application. Teams that operate their own servers should also check FastCGI configurations, PHP-FPM pools, shared sessions, and all environments.
This vulnerability concerns the handling of an HTTP request body that has not been fully consumed before a persistent connection to the PHP backend is reused. In some configurations, leftover data can be interpreted as a second FastCGI request without going through the usual frontend server checks. The official advisory describes a risk of code execution with the privileges of the PHP-FPM worker.
Exposure depends on two main conditions: a frontend that reuses FastCGI connections, and an application path that opens php://input without reading it completely. Documented examples include fastcgi_keep_conn on in nginx, enablereuse=on for Apache mod_proxy_fcgi, and some persistent FastCGI frontends. A standard nginx or Apache setup that closes the backend connection after each request is not affected by the demonstrated PHP-FPM attack.
The cleanup issue also affects persistent LSAPI connections, but the advisory does not demonstrate the same code-execution chain via FastCGI parameters for LSAPI. The LSAPI desynchronization risk should therefore be distinguished from the detailed PHP-FPM exploit.
The presence of PHP-FPM on a server does not prove that CVE-2026-129289 is exploitable: backend connection reuse and how the request body is read are critical factors. Nonetheless, applying the patch is recommended for every affected branch.
On nginx, inspect the effective configuration and its included files:
# Read the effective nginx configuration
sudo nginx -T | grep -n "fastcgi_keep_conn"
# Check FastCGI blocks and their included files
sudo nginx -T | grep -nE "fastcgi_pass|fastcgi_keep_conn"
An absent directive does not mean another frontend or proxy is not reusing the connection. With Apache, check mod_proxy_fcgi and the enablereuse value in particular. For architectures with HAProxy or multiple proxies, document the settings at each hop all the way to the PHP worker.
Temporarily disabling FastCGI connection reuse reduces exposure to this scenario, but updating the runtime remains the priority. The PHP-FPM socket or port must never be exposed directly to an untrusted network.
PHP upload progress tracking can write user-influenced data to a session. The issue occurs when a session written with one serializer is later read using an incompatible format. Content initially treated as a key can then be interpreted as serialized data. In some applications with classes that can be exploited during deserialization, code execution may be possible.
The official advisory specifies several conditions: upload progress tracking must be enabled; the write may use php_binary or php_serialize; another reader uses php on the same session data; and an exploitable object chain must be present for code execution to occur. The mismatch can happen between multiple applications, pools, or virtual hosts that share session storage, even when each has its own configuration.
The patch disables upload progress tracking by default. If a configuration explicitly enables it, the option may remain active: check the effective setting rather than assuming that the changed default is sufficient.
The second vulnerability concerns the file-based session handler, session.save_handler=files. If a write is interrupted at the wrong time, the file may contain some of the new session followed by the end of the old one. If an attacker can influence the stored data and cause or exploit this interruption, a later read may interpret content as serialized objects.
Code execution here requires a combination of conditions: attacker-controlled session data, a partial write interruption, and classes that can form a deserialization chain. Whether authentication is required depends on the application's features. Upload progress tracking is one possible avenue, but it is not the only one: applications that store large untrusted values in their sessions should also be reviewed.
The patch changes how PHP replaces the contents of a session file. Storage systems that replace records atomically are not affected by this specific flaw, but this does not imply that they are secure in other respects.
The following settings are particularly useful to review in the active configuration:
; Examples of settings to review
session.upload_progress.enabled = 0
session.serialize_handler = php
session.save_handler = files
session.save_path = "/path/to/session-storage"
This is not a universal configuration to copy. The serializer, backend, and session directory depend on the application. If multiple processes or pools share the same data, check that their formats are compatible and isolate storage when formats differ.
The session.upload_progress.enabled=0 setting must be applied administratively before uploads are processed. An ini_set() call in application code comes too late to protect the multipart form processing stage.
The November 19 PHP changelog covers more than these three vulnerabilities. It includes, among other things, a PHP-CGI fix for rebuilding PATH_INFO, memory and lifecycle issues in certain engine configurations, a timezone cache issue, and fixes in SOAP, Phar, and network wrappers.
The advisories for CVE-2026-129182 and CVE-2026-129474 apply specifically to PHP 8.5: they concern backtrace handling and should not be presented as identical flaws affecting every branch indiscriminately. The CVE-2026-129496 timezone cache issue requires, in the scenario described by Red Hat, a combination of startup diagnostics, writing to error logs, and a subsequent request.
It is therefore not possible to conclude that a server meets all exploitation conditions based only on its version number. The exact scope can be confirmed by checking the SAPI in use, loaded extensions, and the relevant advisories. Updating remains a priority for installations running affected versions.
A common mistake is to run php -v over SSH and conclude that every site on the server is patched. However, PHP CLI, PHP-FPM, and PHP-CGI may use different executables and versions. A server may host several applications, each associated with its own PHP pool.
php -v
php --ini
command -v php
These commands provide useful information about the terminal environment. They do not prove which version is responding to HTTP requests.
On a Linux server you administer, inspect the relevant services and processes:
# Potentially installed FPM services
systemctl list-units --type=service --all | grep -Ei 'php.*fpm'
# Running PHP-FPM processes
ps -ef | grep '[p]hp-fpm'
# Depending on the distribution, inspect the binary/version for the relevant pool
php-fpm -v
php-fpm8.4 -v
Service and executable names vary: php-fpm, php8.4-fpm, custom paths, or services in containers. Map each virtual host to the correct FastCGI socket or port, then to the correct PHP process.
phpinfo()In WordPress, Tools → Site Health → Info → Server generally shows the PHP version used for requests. Hosting control panels also show the version assigned to each domain.
In a Symfony or custom PHP application, a restricted check or temporary diagnostic log can record the PHP version and SAPI seen by the web request:
<?php
// Run in a controlled administrative context,
// without leaving a public diagnostic endpoint.
error_log(sprintf(
'PHP web runtime: %s / %s',
PHP_VERSION,
PHP_SAPI
));
Remove this diagnostic once the check is complete. Do not expose a public phpinfo() page, as it may disclose sensitive settings. On managed hosting, ask the operator for the patched version number or the security advisory for the package actually installed.
Docker or Kubernetes images must be checked separately from development containers. Running php -v inside a container only tells you about that container; check every relevant image and worker type.
# Example, using the actual container name
docker exec <container_name> php -v
# Identify images in use
docker ps --format '{{.Names}} {{.Image}}'
In a cluster, a partial redeployment may leave old pods running. Check the version actually running in the instances receiving traffic, not just the image tag declared in the repository.
The right patch depends on the hosting setup. PHP.net archives provide upstream releases. On a Linux distribution, use the vendor's packages and security advisories; for an official or custom image, rebuild and redeploy the image containing the patched runtime.
The exact commands depend on the distribution and how PHP was installed. As a general guide:
# Debian / Ubuntu: update the index and permitted packages
sudo apt update
sudo apt upgrade
# RHEL / Amazon Linux: check for and install updates through the vendor repository
sudo dnf check-update
sudo dnf upgrade
Do not run these commands without understanding the impact on other services. Consult the vendor advisory: a security package may include a backport without changing the displayed upstream version. AWS, for example, confirms that patched packages are available for branches 8.2 through 8.5 on Amazon Linux 2023.
# Names are examples and vary by system
sudo systemctl restart php8.4-fpm
# On a system using a generic PHP-FPM service
sudo systemctl restart php-fpm
# Check that the service has restarted
systemctl status php8.4-fpm --no-pager
Run only the command that matches the service actually installed, after validating the maintenance plan. Updating the package without restarting may leave vulnerable PHP processes in memory.
On EC2, ECS, EKS, Fargate, or a custom PHP runtime, operators are responsible for updating their images and services. On Elastic Beanstalk, check whether managed platform updates are enabled and which patched platform is actually deployed. The AWS bulletin states that existing Lightsail instances and custom Lambda runtimes remain the responsibility of their administrators.
After changing the base image, rebuild and redeploy, remove old instances that are still active, and check the runtime in the new version. Simply restarting an unchanged container does not replace rebuilding it on a patched image.
If the update has to wait for a maintenance window, the following workarounds may reduce some attack conditions. They are not interchangeable or equivalent to the patch. Test each change in staging and apply it to the pools or virtual hosts actually in use.
| Scenario | Documented temporary measure | Limitation |
|---|---|---|
| CVE-2026-129289 / PHP-FPM | Close FastCGI connections after each request; disable reuse on the frontend. | Does not fix other runtime defects. |
| CVE-2026-115560 / sessions | If not needed, disable session.upload_progress.enabled in the effective configuration. |
Check writers and readers sharing storage; an explicit configuration may re-enable the option. |
| CVE-2026-126714 / session files | Limit untrusted session data and disable upload progress tracking if unnecessary. | The flaw may persist with other attacker-controlled session writes. |
| Other memory/logging issues | Follow the workarounds specific to each advisory and branch. | A general setting does not eliminate all exploitation conditions. |
Do not rely on a WAF alone. Detection rules may catch some attack patterns, but they do not necessarily cover every variation. AWS has published targeted WAF protections while reiterating that updating is still the only complete fix. A WAF cannot repair a memory or session flaw in the PHP process.
Red Hat also notes that temporary configuration changes must be applied to the correct scope and followed by restarting the master and worker processes. Workarounds can change application behavior or performance: document them and remove them after installing the patched packages if they are no longer needed.
For teams still on PHP 8.2, this update does not change the maintenance deadline: the branch reaches its official end of support on December 31, 2026. The November patch is urgent; migration to a longer-supported branch should be planned and tested separately.
No. WordPress is not the cause of these PHP runtime defects. Risk depends on the server version, SAPI, and conditions specific to each CVE. However, the runtime must be patched even if the CMS and plugins are up to date.
No. The demonstrated attack requires, among other things, reused FastCGI connections and a request whose body is not fully read. Common configurations that close the backend connection after each request do not have the described exploitation chain.
It fixes the November issues on this branch, but does not extend the support period. PHP 8.2 reaches end of life on December 31, 2026, so a separate migration is necessary.
The command line may use a different binary from the web server. Identify the PHP-FPM pool or SAPI associated with the domain, then check the web request runtime in a controlled administrative context.
Not always: some distributions backport fixes to an older branch. Check the full package version, the distribution's security advisory, and the effective deployment rather than relying only on the upstream version.
No. Rules may limit some attacks, but they do not fix runtime defects or cover every exploitation path. Update the binaries in use and restart the relevant processes.
WEB & CYBERSECURITY
Code, dependency and sensitive-path audits turn a technical alert into a controlled action plan.
Enter at least 2 characters to start searching.