Back to Articles

A Month of Remote Bugs and the Case for Virtual Patching

By Tony Perez (@perezbox) • Posted in: server-security, psa •

Look at the last month, especially the last ten days. PHP, Apache, nginx, Go and WordPress all shipped fixes for bugs that can be reached over the network, and the Apache and nginx bugs were found with help from AI. More are coming.

Remote exploitability is the risk that matters. A local bug needs a foothold first, while a remote bug needs only an internet connection and a URL.

Prefer to watch? The video walks through each bug and how virtual patching helps.

The timeline

  • October 21: PHP2Shell. CVE-2026-109618 and CVE-2026-109619, unauthenticated remote code execution in PHP, CVSS v4.0 9.2. We wrote about it then.
  • November 10: Go 1.27.4 and 1.26.11 shipped 12 security fixes. One, CVE-2026-97054 in net/http, lets a request crash a server that uses MaxBytesReader or MaxBytesHandler.
  • November 11: Apache httpd mod_http2, CVE-2026-119618, affecting 2.4.55 through 2.4.70, fixed in 2.4.71. Anthropic's AI-based scanner and Google Cloud Vulnerability Research found it.
  • November 18: nginx, "nginx2root". F5 published five CVEs the same day, led by CVE-2026-123007 (an HTTP/2 heap overflow) and CVE-2026-123633. Fixed in 1.31.9 and 1.30.7.
  • November 18: WordPress 7.1.5, 22 security fixes, backported to every eligible branch back to 4.7.
  • November 18 and 19: The PHP security team pre-announced a CRITICAL release, then shipped 8.2.36, 8.3.37, 8.4.28 and 8.5.13.
Timeline from October 21 to November 19 marking the PHP2Shell disclosure, the Go release, the Apache mod_http2 fix, the nginx2root advisory, WordPress 7.1.5 and the PHP security releases.
Six remotely reachable disclosures in about a month, with most of them landing in the last ten days.

What these bugs actually do

Here's what each one does and who it touches.

PHP2Shell is unauthenticated remote code execution in PHP itself: a stranger on the internet can run commands on your server without logging in. The exploit vectors the NOC WAF blocks abuse PHP's session upload progress field (PHP_SESSION_UPLOAD_PROGRESS), smuggle a path into the session ID (for example PHPSESSID=../..), or send large multipart uploads that PHP spools to disk. Details and mitigations are in the PHP2Shell article.

Go is on this list because application runtimes ship their own HTTP servers rather than sitting behind Apache or nginx, so they carry this kind of exposure too. In net/http, when a request body is larger than the limit set by MaxBytesReader or MaxBytesHandler, the server sets a Connection: close header without synchronization. If the handler reads the body while it writes its response header, the server can panic. An attacker controls the request, so an attacker can crash the service. If you run Go services, this one is yours.

Apache has a bug in how mod_http2 handles headers (in assign_headers()). It only matters on servers that speak HTTP/2, either h2 or h2c, and it can be reached remotely without logging in. The public proof of concept shows memory corruption and crashes. Remote code execution is disputed, but a crash on an internet-facing server is still a bad day. Apache has been here before; we wrote about active exploits against CVE-2021-41773. It affects 2.4.55 through 2.4.70 and is fixed in 2.4.71. If you can't upgrade yet, Protocols http/1.1 takes HTTP/2 out of the picture.

nginx2root is five CVEs from F5, and two of them matter most. CVE-2026-123007 is an overflow of the HTTP/2 flow-control window that leads to a heap buffer overflow. Usually that means a crashed worker, but it can mean code execution on systems with ASLR disabled or where the attacker can bypass ASLR. It touches any HTTP/2 configuration from nginx 1.9.5 to 1.31.8. CVE-2026-123633 is an HTTP/2 use-after-free that applies when nginx serves HTTP/2 to clients, proxies to a backend, and the worker is running low on worker_connections. Wiz demonstrated unauthenticated remote code execution against a server hosting static files over HTTP/2 with TLS, which is about as ordinary a setup as there is.

WordPress 7.1.5 carries 22 security fixes, backported to every eligible branch through 4.7. Four stand out. One is SQL injection in WP_Meta_Query through nested relation values; that's a query builder plugins and themes use everywhere. Another is SQL injection through the front page setting in Customizer changeset previews. A third is an unauthenticated denial of service through batched XML-RPC pingbacks, where one request asks the site to make many outbound pingback calls. The fourth is unauthenticated privilege escalation through Template Part block attributes, which could lead to remote code execution.

PHP shipped 8.2.36, 8.3.37, 8.4.28 and 8.5.13 on November 19. The day before, the security team pre-announced them. Read two lines together: "The highest severity is CRITICAL." and "The issues rated CRITICAL require either non-default configuration or uncommon setups." The changelog includes fixes such as "Use-after-free in magic method backtraces can lead to remote code execution" and "PHP-FPM request smuggling through an unread HTTP request body." Whether a given server is exposed depends on its setup, so check the changelog against yours instead of assuming.

Who finds out first

In coordinated disclosure, a researcher reports a bug privately. The vendor and the distributions get notice, build a fix and stage it. Then the advisory and the fix go public, and everyone, attackers included, sees them at the same moment. After that, distributions build packages for their supported releases, and you schedule a window to install one. The people with early notice get time to prepare. Everyone else (most organizations, and most of the sites we see) starts the clock when the advisory is published.

Diagram of who knows what and when: private report, vendor and distribution fix staging, public advisory, distribution package builds, and the customer's maintenance window, with a bracket showing where virtual patching covers the gap.
Virtual patching covers the gap between the public advisory and a patched server.

Take nginx2root. The fix was public on November 18, and Wiz had already shown unauthenticated RCE. Censys counted about 8.8 million potentially exposed nginx services as of November 19. Ubuntu 24.04, Ubuntu 26.04 and Debian had no fixed package on disclosure day, so a team that wanted to patch immediately had nothing to install from its distribution.

The fix existed, and a lot of people still couldn't use it. Telling them to patch immediately is correct and no help. We saw the same thing with Log4Shell.

AI makes this happen more often

Anthropic's AI-based scanner reported the Apache mod_http2 bug on October 26, and Google Cloud Vulnerability Research found it eight days after that. On the nginx side, Ikotas Labs credited a collaboration with OpenAI. AI shortens the time from "nobody has looked at this code" to "someone has found the flaw."

Defenders use the same tools. But whoever finds a bug first isn't always the one who fixes it, and the window between a public fix and a deployed fix doesn't shrink on its own. Expect weeks like this one to be normal. The advice is still to patch fast, but "fast" depends on someone else's package build.

Patching still matters

Virtual patching is not a replacement for updating. A rule at the edge blocks a known exploit shape and leaves the vulnerable code in place, so the next variation of the exploit may not match the rule. Update when the fix is available, then restart the service, because a package update doesn't change what's already running in memory.

Virtual patching buys time between disclosure and the day you can deploy the fix.

Two layers, two different answers

Server layer: Apache and nginx. A WAF rule can't patch these. The bugs are in how the server handles HTTP/2 frames, before there's a request to inspect. What an edge can do is stop speaking HTTP/2, the same idea as handling protocol attacks at the edge instead of the origin. The NOC edge only offers visitors HTTP/1.1, so it isn't exposed to the HTTP/2 bugs, and the origin only ever sees the edge's HTTP/1.1 connections. An attacker's HTTP/2 frames never reach it, even if it still runs a vulnerable Apache or nginx.

That only works if the origin is locked, and you should patch the origin anyway. On Apache, upgrade to 2.4.71 or set Protocols http/1.1. On nginx, upgrade to 1.31.9 or 1.30.7. If your distribution hasn't built it yet, remove http2 from your listeners until it does.

Application layer: PHP and WordPress. An edge WAF does its best work here, and it's what virtual patching is built on. A provider can write a rule for an application-layer bug and deploy it across every site in hours, without anyone touching the origin, a maintenance window or a plugin update waiting on a vendor.

We've done that all month. The NOC WAF blocks the PHP2Shell exploit vectors at the edge for every site behind it, and we validated the rules against them. On November 18, the day WordPress 7.1.5 shipped, we pushed rules for the four issues described above. We also pushed rules for the Go net/http bug and this week's PHP releases.

None of this works if the origin is open

Edge protection covers only the traffic that goes through the edge. If someone can reach your server directly, they skip the virtual patches and the HTTP/2 protection.

Origin IPs aren't secret. Old DNS records, a mail server on the same box, a forgotten subdomain or a certificate search usually turn them up. With PHP2Shell, we saw a server whose main site was behind the edge while a second hostname on the same box pointed straight at the server's IP. That was the way in.

The edge can't lock your origin for you. The server owner has to, and it takes two layers:

  • Firewall. Allow ports 80 and 443 only from the edge IP ranges, on IPv4 and IPv6, with UFW or iptables.
  • Origin authentication. Make the server require the secret header NOC sends on every request. Put the rule in the default (catch-all) server or VirtualHost too, so a request for an unknown hostname can't land on an unprotected site.

The header is checked after the server parses the request. The Apache and nginx HTTP/2 bugs fire before that, while the server is still handling frames. Against those, only the firewall (or HTTP/2 off on the origin) helps. The header covers application bugs like PHP2Shell, the WordPress issues and the PHP releases.

Diagram of a visitor connecting over HTTP/2 to the NOC edge, the edge connecting to the origin over HTTP/1.1, and an attacker connecting directly to the origin IP and being blocked by the firewall and origin authentication.
The edge speaks HTTP/2 to visitors and HTTP/1.1 to the origin, and a locked origin refuses anyone who skips the edge.

Then test it. From a machine outside the edge, go straight to the origin IP:

curl -sk --resolve example.com:443:ORIGIN_IP https://example.com/

A timeout or a 403 means it's locked, and your homepage means it isn't.

What to do this week

  • Find every nginx and Apache you run, including the ones in containers and appliances. Check versions against 1.31.9 or 1.30.7 and 2.4.71.
  • Where there's no fixed package yet, disable HTTP/2 on the origin and re-check when one lands.
  • Update PHP to 8.2.36, 8.3.37, 8.4.28 or 8.5.13, or a distribution package that lists the fixes. Restart PHP-FPM or Apache afterward.
  • Update WordPress to 7.1.5. Sites that auto-update the minor version may already have it. Check.
  • Review Go services that use MaxBytesReader or MaxBytesHandler.
  • Lock every origin: firewall to the edge ranges on IPv4 and IPv6, plus origin authentication, for every hostname on the box. Then test it with the curl above.

There will be another week like this. If you want an edge that can put a rule in front of an application bug the day it's disclosed, NOC does that for $5 per domain per month.

Sources