Security & privacy

Critical nginx flaws allow remote code execution via HTTP/2 and QUIC

Five high-severity vulnerabilities in nginx, dubbed nginx2root, enable unauthenticated attackers to crash servers or execute commands. Patching to version 1.30.7 or 1.31.9 is urgent for all self-hoste

Illustration of a server rack with security breaches indicated by red lights and a broken padlock
Illustration created for this article

On November 18, 2026, F5 and nginx.org disclosed ten vulnerabilities in the nginx web server, with five critical memory corruption flaws grouped under the name nginx2root. These bugs allow unauthenticated attackers to crash nginx workers or potentially execute arbitrary commands on the host system, including from within Docker containers. The disclosure highlights an immediate patching requirement for the millions of servers running affected versions of this ubiquitous infrastructure software.

What happened

The Xint research team identified five independent vulnerabilities that affect various configurations of nginx, ranging from HTTP/2 and HTTP/3 proxies to mail services and DNS resolvers. Four of these are use-after-free errors, while the most severe, CVE-2026-123007, is an integer overflow leading to out-of-bounds heap read and write operations. This specific flaw has existed since nginx version 1.9.5 released in 2015 and requires only that HTTP/2 be enabled, a common default for TLS deployments. Xint demonstrated that an attacker could exploit this over the public internet to leak memory addresses, bypass Address Space Layout Randomization (ASLR), and achieve code execution with the privileges of the nginx worker process.

Compounding the severity, Xint discovered a sixth issue: a use-after-free bug in the Linux kernel’s SCTP send path, present since Linux 4.15. An attacker who gains a foothold via one of the nginx vulnerabilities can leverage this kernel bug to escalate privileges to root on the host machine, even when running inside a container. Many Linux distributions automatically load the SCTP module when any program opens an SCTP socket, meaning servers that do not explicitly use SCTP may still be exposed. As of mid-November 2026, no kernel fix was available, and researchers were withholding technical details until a patch is released.

Key details

  • CVE-2026-123007: Integer overflow in HTTP/2 handling affecting versions since 1.9.5; allows heap corruption and potential code execution.
  • CVE-2026-123633: Use-after-free in HTTP/2 with proxy_pass when worker connections are low, affecting versions since 1.19.7.
  • CVE-2026-121810: Use-after-free in HTTP/3 (QUIC) with proxy_pass, affecting versions since 1.25.0.
  • CVE-2026-123634: Use-after-free involving the resolver, proxy_pass with variables, and subrequests like mirror or SSI, affecting versions since 0.6.18.
  • CVE-2026-113425: Use-after-free in the mail proxy with auth_http, affecting versions since 0.5.33.
  • Exposure: Censys tracked approximately 8.8 million services running potentially affected versions with HTTP/2 enabled as of November 19, 2026.

Background

Nginx is a high-performance web server, reverse proxy, and load balancer used by a significant portion of the internet’s infrastructure. It handles incoming network connections using an event-driven architecture, which efficiently manages thousands of simultaneous requests but requires careful manual memory management. Use-after-free vulnerabilities occur when a program continues to use a pointer after the memory it points to has been freed, leading to unpredictable behavior or allowing attackers to inject malicious code. In the context of nginx, these bugs often trigger during complex connection teardowns or when handling specific protocol frames like HTTP/2 WINDOW_UPDATE or RST_STREAM messages.

The term nginx2root refers to the chain of exploitation where an initial vulnerability in nginx provides a foothold, which is then escalated to full root access on the underlying operating system via the separate Linux kernel SCTP bug. This combination is particularly dangerous for containerized environments, as it breaks the isolation boundary typically provided by Docker, allowing an attacker to compromise the host server entirely.

Why it matters

For teams managing self-hosted infrastructure, this disclosure represents a critical maintenance event. Nginx is often deployed as the entry point for web traffic, meaning it is directly exposed to the internet. The fact that CVE-2026-123007 has been present for over a decade means that nearly every modern nginx installation is potentially vulnerable unless explicitly hardened. The ability to exploit these bugs without authentication makes them attractive targets for automated scanning and exploitation campaigns, even if no active wild exploitation has been confirmed yet.

The reliance on specific configurations means that some servers may be safe by default, but verifying this requires deep inspection of configuration files. For example, disabling HTTP/2 mitigates the most critical risk, but this may break compatibility with modern clients or impact performance. Furthermore, the kernel-level escalation path means that simply patching nginx is insufficient for complete security; system administrators must also address the underlying OS vulnerability, which currently lacks a public fix. This creates a window of exposure where defense-in-depth strategies, such as restricting direct access to origin servers, become essential.

What you can do

  • Patch immediately: Update nginx Open Source to version 1.30.7 or 1.31.9, or nginx Plus to 37.0.8.1 or 37.3.0.1. Ensure you restart the service to load the new binary, as a configuration reload is not sufficient.
  • Verify backports: If using distribution-provided packages, check the specific package version against vendor advisories, as version strings may not reflect applied security patches.
  • Restrict direct access: Ensure your origin servers are not directly reachable from the internet. Use Cloudflare Tunnel, firewall rules allowing only proxy IP ranges, or mutual TLS authentication to force traffic through a protective layer.
  • Disable unused features: If patching is delayed, disable HTTP/2 and HTTP/3 listeners, remove mail proxy blocks, and avoid using dynamic proxy_pass with variables and subrequests to mitigate specific vectors.
  • Block SCTP module: Prevent the Linux kernel from loading the SCTP module by adding install sctp /bin/false to a modprobe configuration file, reducing the risk of privilege escalation until a kernel patch is available.
  • Audit configurations: Run nginx -T to review active configurations for vulnerable patterns, such as enabled HTTP/2, QUIC listeners, or mail proxy settings, and document findings for compliance.

More news

All news