deniz.in

Markets

Weather

Loading weather

· via dev.to (home feed)

Critical NGINX HTTP/2 flaws allow unauthenticated remote code execution

Two unauthenticated RCE vulnerabilities in NGINX's HTTP/2 stack, disclosed November 18, let attackers run code on any reachable server with HTTP/2 enabled. F5 has shipped fixes.

Critical NGINX HTTP/2 flaws allow unauthenticated remote code execution

What was disclosed

Two critical remote code execution vulnerabilities in NGINX were disclosed on November 18, tracked as CVE-2026-123633 and CVE-2026-123007. According to a technical write-up on dev.to, both flaws sit in the web server's HTTP/2 handling, neither requires authentication, and an attacker who can simply reach the listening port may be able to execute code on the server itself. Both are rated 9.2 under CVSS 4.0. F5, which maintains NGINX, shipped fixes the same day, which makes the immediate task for operators an inventory of exposure.

How the bugs work

CVE-2026-123633 is a use-after-free in the HTTP/2 request-handling path. The program continues to touch heap memory after it has been released, and an attacker who can shape heap contents can arrange for the reused memory to contain data they control.

CVE-2026-123007 is an integer underflow that, per the dev.to article, has been present since NGINX 1.9.5 was released in 2015. A length field wraps around to an enormous value, corrupting memory downstream. The write-up reports that researchers demonstrated code execution against a server doing nothing more than serving static files, with no application backend and no third-party modules involved.

Finding every exposed listener

Both vulnerabilities require HTTP/2 to be enabled, so exposure begins with configuration. The article recommends sweeping a fleet for listening NGINX processes and checking whether each advertises h2 on the wire, rather than relying on package inventories alone.

Several cases are easy to miss. Directives for gRPC imply an HTTP/2 listener even when the listen directive does not mention it, so any configuration using grpc_* deserves scrutiny. Configuration-as-code is another blind spot, since a Terraform or Ansible module may enable HTTP/2 somewhere nobody looks. Edge load balancers that terminate TLS with HTTP/2 on by default also count as exposed if they run a vulnerable build.

Mitigation options and pitfalls

The write-up compares three responses. Upgrading NGINX is the only complete fix, though it requires rollout coordination. Disabling HTTP/2 is a same-day stopgap that removes the attack surface at the cost of multiplexing and header compression; browsers fall back to HTTP/1.1, which most sites tolerate. Blocking HTTP/2 at a load balancer is fast but only sound if every path to the server forces HTTP/1.1.

One exception matters: gRPC runs over HTTP/2, so services with heavy gRPC traffic cannot disable it without breaking clients and must prioritize patching.

Two operational pitfalls are flagged. Since NGINX 1.25.1, HTTP/2 is enabled with a standalone http2 on; directive rather than a flag on the listen line, so searches for older configs using listen 443 ssl http2; need to cover both forms. And after an upgrade, running worker processes keep executing the old code until a reload or restart; the article describes a package upgrade without a restart as a classic mistake that leaves vulnerable workers serving traffic for hours or days.

Detection signals

Memory corruption rarely leaves clean traces, but the write-up lists signals to watch for in NGINX logs: worker processes segfaulting or aborting, often repeatedly; HTTP/2 connection resets clustered in time from a small set of source IPs; and unexpected child processes or new binaries near the NGINX prefix.

A crash by itself does not prove exploitation, but a crash followed by an outbound connection from an NGINX worker is a strong indicator. In that situation the recommendation is to isolate the host and pull the core dump before anything else.

Why it matters

The most uncomfortable detail is that the application behind NGINX is irrelevant here: code can be flawless and still be fronted by a vulnerable server. CVE-2026-123007 sat in the code for roughly a decade, and the dev.to author notes that multiple independent teams found these bugs within weeks of each other, a convergence attributed to AI-assisted code analysis making deep memory-safety bugs practical to locate.

If that trend holds, a bug being hard to find is no longer a defensible security posture. The practical metric shifts from whether you are patched to how quickly you can patch, which argues for pre-built patched images, a tested emergency configuration with HTTP/2 disabled, and advance knowledge of which services cannot tolerate that mitigation.

  • #nginx
  • #security
  • #http2
  • #vulnerabilities
  • #web-servers

Related posts