Security & privacy

NGINX2Root: Critical unauthenticated RCE affects ten years of releases

Hungary's cyber center warns of five NGINX bugs allowing remote code execution. Versions 1.9.5 through 1.31.8 are affected, requiring immediate patching or configuration changes.

Server racks under a glass dome with amber warning lights indicating security alerts.
Illustration created for this article

On November 19, 2026, Hungary's National Cyber Security Center (NBSZ-NKI) issued an urgent alert regarding five critical vulnerabilities in the NGINX web server. Collectively nicknamed NGINX2Root, these flaws allow unauthenticated remote attackers to execute code on vulnerable servers. The issue impacts a wide range of deployments, from simple static sites to complex reverse proxies and containerized applications.

What happened

The core of the vulnerability set is an unauthenticated, remote code execution bug that lets an attacker run commands with the privileges of the NGINX worker process. While this access is limited to the worker user initially, the alert notes that chaining this exploit with a separate Linux kernel privilege-escalation bug in the SCTP subsystem can lead to full root access. In specific environments, this chain may also facilitate a container escape, compromising the host system.

Five distinct Common Vulnerabilities and Exposures (CVEs) make up the NGINX2Root cluster. Two relate to HTTP/2 handling, including a data-flow control bug and a use-after-free error in connection handling. Another CVE affects HTTP/3 and QUIC upstream request processing, while two others involve use-after-free errors in DNS resolution for proxy configurations and the mail proxy under certain authentication setups. The HTTP/2 vulnerability alone affects official NGINX versions from 1.9.5 through 1.31.8, covering roughly ten years of software releases.

The alert does not provide CVSS severity scores, nor does it confirm active exploitation in the wild at this time. However, the potential for root access and container escapes makes this a high-priority incident for any team managing self-hosted infrastructure. The disclosure originated from researchers at xint.io and was amplified by the Hungarian homelab community AikaHub before reaching international security news outlets.

Key details

  • Affected versions: Official NGINX releases 1.9.5 through 1.31.8 are vulnerable when HTTP/2 is enabled.
  • Primary risk: Unauthenticated remote code execution with worker-level privileges, potentially escalating to root.
  • Patch targets: Upgrade to version 1.30.7 (stable branch) or 1.31.9 (mainline branch) or newer.
  • Container impact: Docker images containing NGINX, such as Nginx Proxy Manager, must be pulled and recreated; host updates do not fix containerized instances.
  • Mitigation limits: Disabling HTTP/2 only mitigates two of the five CVEs, leaving HTTP/3, DNS, and mail proxy vectors open.
  • Verification: External probes may be misleading if a CDN like Cloudflare sits in front of the origin server.

Background

NGINX is a ubiquitous piece of internet infrastructure, often used as a reverse proxy to route traffic to backend applications. Many self-hosters rely on pre-packaged Docker images or distribution packages that bundle NGINX without explicit user configuration. This opacity means administrators may not realize they are running a vulnerable version until they check specifically. The term "use-after-free" refers to a memory corruption bug where a program continues to use a pointer after the memory it points to has been freed, often leading to crashes or arbitrary code execution.

Privilege escalation via the Linux kernel SCTP subsystem is a separate but compounding factor. SCTP is a transport layer protocol less common than TCP or UDP but still present in many standard Linux kernels. If an attacker gains initial access via NGINX, they can leverage this kernel bug to break out of the restricted worker environment and gain full control over the operating system. This chaining effect transforms a web server bug into a total system compromise.

Why it matters

For teams running their own software, the breadth of affected versions is alarming. A decade of releases means that almost any legacy server or stable production environment is likely vulnerable unless it was recently updated to the very latest patch levels. The risk is not just theoretical data theft; the potential for container escape means that a single compromised web service could jeopardize the entire host machine and other co-located services. This is particularly dangerous for multi-tenant setups or shared hosting environments managed by small IT teams.

The mitigation path is complicated by the use of containers and distribution backports. Simply checking the version number via command line tools may yield false negatives if the Linux distribution has applied security patches without changing the upstream version string. Conversely, updating the host operating system does not automatically update NGINX running inside a Docker container. Administrators must verify both the host package status and the specific image tags used in their container orchestration tools. Failure to address all vectors, such as HTTP/3 or mail proxies, leaves partial exposure even after disabling HTTP/2.

What you can do

  • Upgrade immediately: Install NGINX 1.30.7 or 1.31.9 from your distribution’s repository or pull the latest official Docker images.
  • Verify distro backports: Check your Linux distribution’s security advisory page rather than relying solely on nginx -v, as patches may be backported without version bumps.
  • Recreate containers: If using Docker, pull the patched image and restart the container to ensure the new binary is loaded.
  • Disable risky protocols: If immediate upgrading is impossible, disable HTTP/2 to block two CVEs, and review configurations for HTTP/3, dynamic DNS resolvers, and mail proxy usage.
  • Run local checks: Execute the provided grep commands on the server to identify enabled modules like http_v2_module and directives such as resolver or proxy_pass.
  • Monitor logs: Watch for unusual outbound connections, unexpected worker process crashes, or strange commands spawned by the web server user.

More news

All news