# PHP: Critical Patches Released on November 19, 2026, and Servers to Check

> PHP patches released on November 19, 2026: versions 8.2.36 to 8.5.13, PHP-FPM and session CVEs, configurations actually exposed, and an update guide.

Web & Cybersecurity · PHP Maintenance

## PHP: Critical Patches Released on November 19, 2026, and Servers to Check

PHP released new security patches on November 19. Patched versions, PHP-FPM and session exploitation conditions, WordPress/Symfony checks, and update procedures.

![PHP-Security-Updates-November-2026.webp](https://sdx-development.com/media/News/PHP-Security-Updates-November-2026.webp?v=1795169907)

[Web & Cybersecurity](https://sdx-development.com/en/news/web-cybersecurity)Published on 20 November 2026 at 11:21

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.

 

Key takeaways 

## Patch the runtime, then confirm the restart

 

**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.

 

**In this article** 

[Patched versions](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#versions) [Who is affected?](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#perimetre) [PHP-FPM](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#fpm) [Sessions](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#sessions) [Other patches](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#autres) [Check your server](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#verifier) [Update](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#corriger) [Temporary mitigations](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#attente) [Checklist](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#checklist) [FAQ](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#faq) [Sources](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check#sources)

 

## Which PHP versions fix the November 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.

 

Versions supplied by your hosting provider 

## Upstream version numbers do not always match patched package versions

 

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.

 

## WordPress, Symfony, and SaaS: who should check their installation?

 

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.

 

Shared / managed hosting 

### Identify the web server version

 

Check your hosting provider's dashboard and ask when PHP patches are deployed. Updating WordPress or Composer does not replace updating PHP itself.

 

VPS / containers / cloud 

### Check every runtime in use

 

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.

 

## CVE-2026-129289: PHP-FPM and FastCGI connection reuse

 

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.

 

Do not overgeneralize 

## Using PHP-FPM alone does not make a site exploitable

 

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.

 

### What should you check in the frontend server?

 

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 sessions: two distinct vulnerabilities, two sets of conditions to understand

 

### CVE-2026-115560: incompatible serialization formats

 

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.

 

### CVE-2026-126714: session files partially overwritten

 

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.

 

### Check session settings

 

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.

 

## What about the other PHP-CGI, engine, and extension patches?

 

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.

 

## How do you check the PHP version actually used by a site?

 

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.

 

### Step 1: Check the CLI version without confusing it with the website

 

```
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.

 

### Step 2: Identify the web server runtime

 

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.

 

### Step 3: Check from the application without exposing ` 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.

 

### Step 4: Inventory containers and background tasks

 

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.

 

## How do you update PHP without unnecessarily disrupting WordPress or Symfony?

 

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.

 

## Seven-step update procedure

 
1. **Inventory.** List domains, pools, versions, CGI/FPM components, scheduled tasks, and container images.
2. **Assess exposure.** Check FastCGI reuse, session settings, extensions, and vendor advisories without unnecessarily delaying the patch.
3. **Back up.** Prepare application and database backups, configuration snapshots, and a rollback plan.
4. **Update.** Install the security package or rebuild the image from a patched base; avoid jumping straight to another major branch by default.
5. **Restart.** Restart PHP-FPM, Apache, or the relevant processes; recreate containers and workers that still have the old engine in memory.
6. **Confirm.** Check the binary and version actually used by web requests, then consult the vendor bulletin if fixes have been backported.
7. **Test.** Test authentication, sessions, file uploads, payments, asynchronous tasks, caches, and logs after deployment.

 

### On Debian, Ubuntu, RHEL, or Amazon Linux

 

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.

 

### Restart the right services

 

```
# 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.

 

### What about AWS or Docker environments?

 

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.

 

## Which temporary measures can reduce exposure before patching?

 

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.

 

## Final checklist: what should you check on your sites today?

 

## Before considering the incident closed

 
1. **Version.** The PHP branch and package used by each site have been identified and patched.
2. **FPM / CGI.** Backend connections, the SAPI, and configurations for the different pools have been checked.
3. **Sessions.** Serialization formats, upload progress, and shared storage have been reviewed.
4. **Deployment.** Processes have restarted, and old images or pods have been replaced.
5. **Functionality.** Login, carts, forms, uploads, business tasks, and logs are still working.
6. **Record keeping.** The date, package versions, security advisories, and post-patch checks have been recorded.

 

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.

 

## FAQ: November 2026 PHP patches

 

Is my WordPress site automatically vulnerable?

 

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.

 

Is PHP-FPM always vulnerable to CVE-2026-129289?

 

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.

 

Is PHP 8.2.36 enough to stay on PHP 8.2 after December?

 

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.

 

Why do PHP CLI and my site show different versions?

 

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.

 

Does an old-version Linux package necessarily mean it is unpatched?

 

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.

 

Can a WAF replace PHP patches?

 

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.

 

View official sources 8 references

 

- [PHP.net — November 2026 security announcements](https://www.php.net/archive/2026.php), availability of the four patches and the preliminary November 12 advisory.
- [PHP.net — PHP 8 changelog](https://www.php.net/ChangeLog-8.php), CVEs and components fixed in each branch.
- [PHP.net — Supported versions](https://www.php.net/supported-versions.php), PHP 8.2 support ends on December 31, 2026.
- [PHP Security Advisory — CVE-2026-129289](https://github.com/php/php-src/security/advisories/GHSA-qc49-hpvq-g2w6), FastCGI reuse conditions, patches, and workarounds.
- [PHP Security Advisory — CVE-2026-115560](https://github.com/php/php-src/security/advisories/GHSA-658j-r8rw-q6mx), incompatible session serialization formats.
- [PHP Security Advisory — CVE-2026-126714](https://github.com/php/php-src/security/advisories/GHSA-fm2m-fjf5-v3cp), partially written file-based sessions.
- [Red Hat — RHSB-2026-020](https://access.redhat.com/security/vulnerabilities/RHSB-2026-020), analysis of severe vulnerabilities, configurations, and workarounds.
- [AWS — Bulletin 2026-190](https://aws.amazon.com/security/security-bulletins/2026-190-aws/), affected components, Amazon Linux updates, and operational responsibilities.

WEB & CYBERSECURITY

## Build a reliable web foundation before an incident.

Code, dependency and sensitive-path audits turn a technical alert into a controlled action plan.

- Clear priorities and risks
- Tested fixes with a rollback plan
- Long-term maintenance

[Request a project audit](https://sdx-development.com/en/contact)[View services](https://sdx-development.com/en/services)

---

[View the HTML page](https://sdx-development.com/en/news/web-cybersecurity/critical-patches-released-on-november-19-2026-and-servers-to-check)
