First PHP2Shell, then Node2Shell, and now Java4Shell and NGINX. November really isn’t giving infrastructure teams much of a break. 😅
What caught my attention in the 18 November NGINX disclosure was the static-file case. You can serve an ordinary file, have no application backend at all, and still expose a flaw that researchers used to run code remotely. The component handling HTTP/2 is enough.
If you run NGINX with a reachable HTTP/2 listener, I will prioritise the update. The first fixed upstream releases are 1.30.7 stable and 1.31.9 mainline. For distribution packages, NGINX Plus and products that bundle it, check the supplier’s build. There’s a good Ubuntu example below.
Two bugs with different prerequisites
CVE-2026-123007 affects HTTP/2 flow control. A client tells the server how much response data it can accept. NGINX has to account for data it’s queued, including data it later cancels. In affected releases that accounting can go wrong and corrupt memory in a worker. The code dates back to 1.9.5. Wiz demonstrated unauthenticated remote code execution (RCE) against NGINX serving static files.

CVE-2026-123633 is a use-after-free. Here a worker still has a reference to memory that’s been freed. F5 describes a narrower deployment: NGINX accepts HTTP/2 client requests, proxies them to a backend, and the worker is running low on connection slots (worker_connections). The affected code dates back to 1.19.7. That distinction matters when you’re triaging a static site alongside an API gateway.
What does “NGINX2Root” actually mean?
Code execution starts with the permissions of the NGINX worker. In Xint’s demonstration, reaching root on the host from inside a container required a separate Linux kernel vulnerability. I will review what the worker can already read and reach: mounted files, credentials and backend services. If the worker has access to something sensitive, losing it is serious enough on its own.
“But we’re behind a CDN or WAF”
I will start with a drawing of the connection path. Cloudflare published a useful example on 20 November. For a proxied hostname, the client’s HTTP/2 connection ends at Cloudflare. Its edge makes a new connection to the origin and manages flow control independently, even when that second connection also uses HTTP/2. That behaviour breaks the disclosed client-controlled frame sequences on the proxied route.

Now take the same origin and put a TCP load balancer in front with TLS passthrough. The client still negotiates HTTP/2 with NGINX. Or keep the CDN, but leave an origin listener reachable via another public or internal route. The edge can only protect traffic that goes through it. When I review a setup like this, I want to know which component actually reads the client’s HTTP/2 frames on each route.

What I will check before patching production
- Find the nginx binary serving the traffic. Run
nginx -vandnginx -Vinside the workload. The capital V also shows build options. Look for--with-http_v2_module, then check whether the listener enables it. A host package, an ingress controller and an application container can all carry different builds. - Read the configuration the service actually loads. Check the service’s startup arguments for an alternative config or prefix.
nginx -Ttests and prints the configuration, including included files. Keep that output local because it can contain sensitive settings. Look forhttp2 on;or the olderlisten 443 ssl http2;form. The standalone directive arrived in 1.25.1. - Match the package to its supplier. On Ubuntu,
dpkg-query -W nginxgives you the full installed revision when NGINX comes from the distribution. Ubuntu 24.04 LTS lists1.24.0-2ubuntu7.20as fixed for both CVEs. A rule that flags every banner below 1.30.7 would send you chasing an already-patched system. For a controller or appliance, match the product release against its own advisory. - Replace the running workload. On a package-based install, use the supplier’s supported restart or binary upgrade procedure. A configuration reload leaves the existing master executable in place. For containers, roll out the fixed image and check the image digest on the running replicas. A new tag in the registry tells you very little about the pods still receiving traffic.
- Verify the rollout and the next deployment. Check that the old workers or pods have drained. Exercise a real application route, including gRPC if you use it, and watch worker errors and upstream failures. Record the running package revision or image digest. Update the base image, deployment template and rollback target so the next release can’t quietly bring the vulnerable build back.
If the maintenance window can’t move
CERT-EU and Xint describe temporarily disabling HTTP/2 on exposed listeners to remove these two paths. On releases that support the standalone directive, check inherited settings, set http2 off; where appropriate and remove any legacy http2 listener parameter. On older releases, remove that listener parameter. Test the exact configuration with nginx -t, then verify what a new connection actually negotiates after rollout. Existing long-lived connections and native gRPC clients deserve their own check.
F5 lists “None” in the workaround field of both CVE records. I will recommend disabling HTTP/2 as a temporary change, give it an owner and keep the binary upgrade scheduled. The same NGINX release also fixes issues in HTTP/3, the resolver and the mail proxy. Switching off HTTP/2 leaves those untouched.
What AI changed in this disclosure
Wiz says its Atlas system found both HTTP/2 bugs and its researchers used AI models to validate their impact. Xint describes a different sequence. One of its researchers found the flow-control bug, then an automated scan found four more NGINX vulnerabilities a few days later. The flow-control code had been there since 2015. A busy month of disclosures can tell us something about how people are looking, even when the affected code has barely changed.

Java4Shell is another example. Calif says Quang Luong spent about an hour finding the bug in OpenJDK’s accelerated Base64 decoder and two more hours producing the first working exploit, for less than US$200 in tokens. That figure describes one researcher’s run. The affected path depends on the runtime, CPU features and what an application lets a caller reach. Those details tend to get lost between the original write-up and the headline.
For NGINX, Rapid7 demonstrated RCE for CVE-2026-123007 in a specific container setup. CERT-EU’s advisory on 18 November said it had seen no reports of exploitation in the wild at that point.

Final thoughts
I think AI has accelerated the discovery of vulnerabilities, shifting infrastructure security from periodic manual audits to continuous automated defense and defense at scale.


