19 November 2026 | Updated following PHP's security releases

Some people have been counting down the days until Grand Theft Auto VI. Others have been counting vulnerable NGINX instances, checking package repositories and wondering whether their maintenance windows will ever end. And today, apparently, both groups have something to celebrate. Although I suspect one of them is having considerably more fun.

Rockstar Games scheduled GTA VI for 19 November 2026, finally bringing players back to Vice City. A return we've been waiting for since, well, practically forever. But while millions of people are preparing to explore the streets of Leonida, those responsible for keeping the actual internet running have received a slightly different invitation: another round of critical security updates. And just when yesterday's NGINX patching started looking manageable, PHP decided to join the party.

First, NGINX2Root. Because Apparently One CVE Wasn't Enough.

On 18 November, NGINX released security updates addressing ten vulnerabilities, including a collection of memory corruption and use-after-free issues that researchers have collectively referred to as NGINX2Root.

Among the most serious is CVE-2026-123007, a memory corruption vulnerability in HTTP/2 flow control. Under vulnerable conditions, specially crafted HTTP/2 traffic can potentially lead to remote code execution within the affected NGINX worker process. No authentication is required to reach the affected HTTP/2 processing path.

Other notable vulnerabilities include CVE-2026-123633, involving HTTP/2 use-after-free behaviour; CVE-2026-121810, affecting HTTP/3; CVE-2026-123634, involving DNS resolver response processing; and CVE-2026-113425, affecting NGINX's mail proxy module. Not all ten issues have the same severity or exploitation requirements, but collectively they make a compelling argument for prompt patching.

The upstream fixes arrived in NGINX 1.30.7 (stable) and 1.31.9 (mainline). Distribution-maintained packages may carry backported fixes under different version numbers.

For anyone operating a handful of websites, that's one thing. For administrators responsible for fleets of servers, reverse proxies, Kubernetes ingress controllers and container workloads, it means inventory checks, configuration reviews, controlled deployments, process restarts and verification. And not merely confirming that the package manager reported success.

Then there's the inevitable question: what about the NGINX instances hiding inside container images nobody has rebuilt for months?

Exactly.

Finally Done? PHP Would Like a Word.

On 18 November, the PHP Security Team announced that new security releases for all supported PHP versions would be published on 19 November, between 14:00 and 14:30 UTC. That's 15:00–15:30 here in Norway, conveniently positioned to interfere with an otherwise perfectly reasonable afternoon.

And right on schedule, the updates arrived.

PHP 8.5.13, 8.4.28, 8.3.37 and 8.2.36 are now available, addressing multiple vulnerabilities across PHP's runtime, session handling, FastCGI Process Manager (PHP-FPM), CGI implementation and other components.

The PHP Security Team had already warned that the highest severity would be Critical, while emphasising that the critical issues require non-default configurations or uncommon deployment setups. That distinction still matters. A critical vulnerability announcement does not automatically mean every installation is remotely exploitable.

Nevertheless, the complete security disclosures make for some rather uncomfortable reading.

One particularly significant issue is CVE-2026-115560, now officially rated Critical with a CVSS v4.0 score of 9.2. It involves PHP's session upload progress functionality and incompatible session serialization formats, potentially allowing remote code execution under specific conditions.

And here's where the final advisory gets particularly interesting.

The initial information suggested a rather unusual scenario: an application configured to use php_binary or php_serialize subsequently switches its session handler to php at runtime, before calling session_start(), while session upload progress remains enabled.

That is hardly a typical configuration. But unusual configurations have an unfortunate habit of existing somewhere, particularly in environments with older applications, historical workarounds and years of accumulated technical decisions.

The final advisory, however, confirms that changing the session handler at runtime isn't even necessary.

The vulnerable condition can also arise between separate applications, virtual hosts, PHP-FPM pools or processes using different serialization formats while accessing the same session storage and session identifier.

Under these circumstances, attacker-controlled upload progress data written using one serialization format can subsequently be interpreted as serialized object data by another PHP session reader. If the receiving application has a suitable object gadget chain, arbitrary code execution may follow.

PHP's security advisory documents successful command execution using Guzzle and Monolog gadget chains.

Now, to be clear, this does not make every shared hosting environment vulnerable. The necessary conditions still have to exist, including compatible access to shared session data, conflicting serialization formats and the relevant application behaviour. But it highlights something that administrators of multi-application environments should pay close attention to: separate applications or PHP-FPM pools do not necessarily have isolated session storage.

PHP previously recommended disabling session upload progress as a mitigation:

session.upload_progress.enabled=0

The setting must take effect before request parsing, through an appropriate server-level configuration such as php.ini or PHP-FPM configuration, followed by restarting affected workers. An application-level ini_set() is insufficient for this purpose.

The newly patched PHP releases now disable session upload progress by default and introduce additional restrictions around runtime session configuration changes. Administrators who explicitly enable the feature must still review their configurations.

Interestingly, this mitigation was already recommended in October in connection with CVE-2026-109619, one of the two PHP2Shell vulnerabilities. Administrators who retained that configuration may therefore have blocked this particular attack path before today's disclosure.

That's the good news.

The slightly less entertaining news is that CVE-2026-115560 is far from the only vulnerability fixed today.

And Then There Were More. Because Of Course There Were.

The November release also fixes CVE-2026-129474, another Critical vulnerability with a CVSS v4.0 score of 9.2, affecting PHP 8.5 versions before 8.5.13.

This one involves a use-after-free condition when PHP collects arguments for backtraces involving magic methods such as __call() and __callStatic(). Under particular conditions, an unauthenticated attacker can trigger a fatal error that causes PHP to access memory which has already been freed.

Remote code execution has been demonstrated, although the documented attack depends on a combination of application behaviour, memory conditions and runtime configuration, including fatal-error backtraces containing function arguments.

PHP 8.5 also received a fix for CVE-2026-129182, another Critical use-after-free involving fatal-error backtrace state across request shutdown and subsequent execution. The security advisory describes potential remote code execution, but importantly, actual RCE has not been demonstrated through the specific newly identified entry points.

Then there's CVE-2026-129496, involving a timezone cache use-after-free with potential remote code execution consequences, and CVE-2026-129538, involving out-of-bounds memory access in PHP-CGI.

The fixes don't stop there. The changelog also includes session file handling problems, request smuggling in PHP-FPM, memory corruption in other extensions and a PHP-FPM vulnerability that deserves particular attention in multi-tenant environments.

CVE-2026-129291, rated High with a CVSS v4.0 score of 8.8, involves a use-after-free condition in PHP-FPM's handling of worker output events.

Under specific conditions, an attacker who already has code execution within an unprivileged PHP-FPM worker may be able to escalate execution to the FPM master process, which commonly operates with root privileges.

The published advisory describes reproduced root command execution in affected PHP Docker environments.

That does not mean that every vulnerable PHP-FPM service can be remotely compromised as root. The attacker must already be able to execute code in a worker, and the relevant configuration and operating system conditions must be present. But the possibility of crossing that privilege boundary makes this a particularly important issue for hosting operators.

So, within roughly 24 hours, we have moved from critical NGINX vulnerabilities involving HTTP/2 and other components to a substantial PHP security release addressing multiple memory safety problems, session deserialization risks, request smuggling and privilege escalation.

Lovely timing, really.

And unlike GTA VI, nobody is particularly excited about unlocking these new features.

The Real Problem Isn't Just Patching

The interesting part of these successive disclosures is not simply that serious vulnerabilities keep appearing. That's an unavoidable reality of software engineering. NGINX and PHP are mature, heavily scrutinised projects with enormous deployment footprints. They also sit in extremely sensitive parts of modern infrastructure.

NGINX frequently handles incoming traffic before it ever reaches an application. PHP executes application logic, processes user input and interacts with databases and sessions. A weakness in either can have consequences far beyond the individual component.

And the infrastructure has become increasingly fragmented. A server might have an updated system package while still running an outdated NGINX container. A Kubernetes cluster might have an up-to-date control plane while its ingress controller remains vulnerable. A PHP package may have been updated successfully while old workers continue executing the previous version.

The newly disclosed PHP session vulnerability adds another dimension. Two applications might be running in separate PHP-FPM pools, using different configuration files and entirely different session serialization formats, while still sharing a session storage directory that creates an unexpected security dependency.

This is why vulnerability management is not fundamentally a matter of running apt upgrade and going home. The actual work is knowing what runs where, understanding which configurations are exposed, determining who owns the updates and verifying that remediation has genuinely taken effect.

For PHP administrators, the immediate task is to deploy the relevant fixed release for their PHP branch, or an equivalent vendor-maintained security update, and verify the running processes. For containerised workloads, that means rebuilding and redeploying affected images rather than assuming that updating the host solves the problem.

And then, of course, checking whether the underlying applications still work.

There is also a distinction worth maintaining between a disclosed vulnerability, a potentially exploitable configuration and an actual compromise. Security discussions become unnecessarily theatrical when those three things are treated as interchangeable. Being proactive does not require exaggerating the threat.

A CVSS score tells us something important about severity under defined conditions. It does not tell us that every server in the world is exploitable, or that exploitation has actually occurred.

The distinction matters, particularly when security communication is increasingly reduced to dramatic headlines, red warning banners and an endless stream of CVE numbers.

So, Can We Finally Go to Vice City?

Rockstar has spent years developing a fictional world full of criminals, questionable decisions and unpredictable consequences. Meanwhile, the real internet continues providing its own remarkably convincing simulation.

The timing is almost poetic. NGINX releases ten security fixes on 18 November. PHP follows with critical updates on 19 November. And GTA VI, of all things, is scheduled for exactly the same day.

Of course, security maintenance doesn't stop because a long-awaited game is launching. Nor should it. But the contrast is rather entertaining.

If you're responsible for infrastructure today, the sensible order is probably to verify the NGINX patches, assess the newly published PHP vulnerabilities, check whether your workloads are actually exposed, deploy the relevant fixes and make sure nothing unexpectedly broke along the way.

Then perhaps there will be time for Vice City.

Assuming nobody discovers another critical CVE before dinner.

Welcome to November 19, 2026. Some of us are chasing virtual criminals. Others are trying to keep the real ones out of production.

And somewhere, on a perfectly innocent desk, a game controller remains untouched.


Technical references

Originally published on 19 November 2026 ahead of the scheduled PHP security releases. Updated the same day following publication of PHP's official changelog and security advisories.