Free NGINX2root scanner - check NGINX servers for CVE-2026-123007

Scan type
  • Light scan

Read the Terms of Service

Scan your NGINX servers for NGINX2root (CVE-2026-123007 and CVE-2026-123633), the HTTP/2 flaws that can lead to unauthenticated remote code execution, and get a PDF report with the documented finding.

The scanner is a passive version check. It reads the NGINX version from the Server header, specific endpoints, or the default error page and reports affected versions. It also sends an HTTP/2 connection preface over cleartext TCP and notes in the result whether HTTP/2 is enabled. HTTP/2 over TLS needs ALPN, which the scanner cannot send, so on HTTPS ports HTTP/2 is reported as not confirmed. It provides the evidence behind the result and the fixed release to install. It never sends the attack traffic.

Running NGINX across many servers and ingresses? The Network Vulnerability Scanner maps them across your attack surface.

Does NGINX2root affect my NGINX servers?

NGINX2root is five separate flaws, and each one depends on how you configured NGINX:

  • CVE-2026-123007: HTTP/2 enabled (NGINX 1.9.5 through 1.31.8)

  • CVE-2026-123633: HTTP/2 with requests forwarded to an upstream server (1.19.7 through 1.31.8)

  • CVE-2026-123634: a resolver, a proxy_pass target taken from the request, and mirror

  • CVE-2026-121810: HTTP/3 with requests forwarded to an upstream server

  • CVE-2026-113425: the mail proxy with proxy on and auth_http

Fixed in NGINX Open Source 1.30.7 (stable) and 1.31.9 (mainline), released November 18, 2026, and in NGINX Plus 37.0.8.1 and 37.3.0.1.

This free scanner checks the two HTTP/2 flaws, the most widespread ones: it reads the NGINX version and checks whether HTTP/2 is on over cleartext TCP. The other three depend on configuration you check on the host (see How to mitigate).

How we detect NGINX2root (CVE-2026-123007, CVE-2026-123633)

Confirming NGINX2root directly means sending the attack itself: for CVE-2026-123007, a long flood of HTTP/2 control frames built to corrupt a worker's memory. That can crash the service. We don't do it.

Instead, our NGINX2root Scanner checks the two conditions you can see from the outside: the NGINX version and HTTP/2 over cleartext TCP.

  1. Method: the scanner connects to ports 443, 8443, and 80 and:
    • reads the NGINX version from the Server header or the default error page
    • asks for HTTP/2 (h2c) on cleartext ports
  2. Match condition: the reported version falls between 1.9.5 and 1.31.8 (excluding stable 1.30.7 and later) and the server negotiates HTTP/2 over cleartext TCP.
  3. What we can't see from the outside:
    • Backported fixes. Ubuntu, Debian, and other distributions fix NGINX without changing the version it reports.
    • Whether NGINX forwards requests to an upstream server, which CVE-2026-123633 needs.
    • The configurations behind CVE-2026-123634, CVE-2026-121810, and CVE-2026-113425.
    • Servers that hide their version (server_tokens off), or sit behind a CDN or reverse proxy that answers instead.
    • The Linux kernel SCTP bug that turns worker access into root.
  4. How to read a finding: "this server runs an affected NGINX version with HTTP/2 on over cleartext TCP." Then check the full package version on the host. If the scan can't read a version, treat the result as unknown, and check it with nginx -v.
  5. Safety: the scanner sends standard HTTP requests and an HTTP/2 connection preface over cleartext TCP. It never sends the HTTP/2 frame sequence that triggers CVE-2026-123007.
  6. CVE coverage: CVE-2026-123007 and CVE-2026-123633.
  7. Evidence and confidence: each finding includes the Server header, the NGINX version, the negotiated protocol, and the port.
NGINX2root (CVE-2026-123007) finding in a Pentest-Tools.com scan report, showing nginx 1.31.8 read from the Server header on port 18443

NGINX2root is five bugs with five different preconditions, and the most widespread one only needs HTTP/2 to be on. From the outside, we can see two things: the NGINX version your server admits to, and whether it speaks HTTP/2. So that's what this free scanner checks.

We don't send the attack traffic. It's built to corrupt a worker's memory, and it could knock over the server you're trying to protect.

Treat a finding as your cue to check the package on the host. Ubuntu and Debian backport fixes without changing the version string, so the version alone doesn't settle it.

Product Security Manager at Pentest-Tools.com

Free NGINX2root scanner report (PDF) sample

The report helps anyone who needs to patch NGINX or hand the finding to the team that owns it. For NGINX2root, the vulnerability scan report includes:

  • the finding with the tested host and port, the Server header, the NGINX version, and the negotiated protocol

  • the fixed releases for NGINX Open Source and NGINX Plus

  • the host-level checks you still need to do yourself: the full package version, upstream proxying, and the configurations behind the other three flaws

  • severity and step-by-step remediation, including how to disable HTTP/2 as a temporary control

The scan also collects open ports and detected technologies.

Download sample report (PDF)

What is NGINX2root?

Technical details

NGINX2root is the name Xint gave five memory safety flaws in NGINX. Each one leads to remote code execution on its own, in a different configuration.

The most widespread, CVE-2026-123007, is an integer overflow in HTTP/2 flow control. NGINX deducts credit from a connection's send window when it queues response data, and returns that credit if the stream is canceled before the data goes out. In between, a client can raise the window again with WINDOW_UPDATE frames. When the stream is canceled, the credit comes back a second time, and nothing checks the result against HTTP/2's maximum.

From there, the window wraps around, NGINX computes a negative frame size, and that value turns into a huge memory-copy length. On x86-64 glibc, the copy runs only a short distance instead of crashing, which gives an attacker both an out-of-bounds write and a leak of memory addresses. Xint used the two to overwrite a cleanup function pointer and run commands as the NGINX worker.

CVE-2026-123633 is a use-after-free. When a worker runs low on connection slots, NGINX can close an HTTP/2 connection it wrongly marked as idle, while a request on that connection is still opening an upstream connection. The request's memory is freed, and the upstream code keeps using it.

The bug behind CVE-2026-123007 shipped with NGINX's first HTTP/2 release, 1.9.5, in 2015. Xint found it while preparing for ZeroDay Cloud 2026, and a fully automated Xint scan found the other four a few days later.

What an attacker can do by exploiting NGINX2root

  • Run commands on the server without credentials, with the NGINX worker's privileges. Xint demonstrated this over public IP addresses on AWS, GCP, and Azure.
  • Get root on the host by chaining a separate, unpatched Linux kernel bug in SCTP. Xint did this from inside a Docker container, which gave it the host and every container on it.
  • See the traffic the worker handles, since NGINX usually terminates TLS, and reach the backend servers it proxies to.
  • Crash workers, even with a failed attempt.

Xint omits the final steps of its exploits, and the root chain depends on whether SCTP is reachable on the host.

Potential business impact: what this can mean for your organization

NGINX usually sits in front of everything else, so the risk follows what it fronts:

  • Reverse proxies and load balancers: a foothold there exposes decrypted requests, session cookies, and credentials in transit, and a path to every backend.
  • Kubernetes ingress: the ingress is the cluster's front door, and the kernel chain can turn one compromised pod into the whole node.
  • Shared hosting and multi-tenant setups: root on the host reaches every customer site and container on it.
  • Availability: crashed workers drop the requests they were serving.

If a compromise leads to a personal data breach, GDPR gives you 72 hours to notify, and NIS2 asks organizations in scope for an early warning within 24 hours.

NGINX versions vulnerable to NGINX2root

NGINX Open Source and NGINX Plus are affected. Status as of November 18, 2026:

DistributionVulnerable versionsFixed in
NGINX Open Source (CVE-2026-123007)1.9.5 through 1.31.81.30.7 (stable), 1.31.9 (mainline)
NGINX Open Source (CVE-2026-123633)1.19.7 through 1.31.81.30.7 (stable), 1.31.9 (mainline)
NGINX Plus (CVE-2026-123007)R33, 37.0.0 and later37.0.8.1, 37.3.0.1
NGINX Plus (CVE-2026-123633)R33, 37.0.0 and later37.0.7.1, 37.2.0.1
Official Docker imagesTags before the fixUpdated tags (mainline points to 1.31.9)
Alpine Linux 3.24 and edgePackages before the fix1.30.7-r0
Ubuntu (16.04 through 26.10) and DebianAffectedNo fixed package as of November 18, 2026
OpenResty1.31.8.1 and earlierNo fix as of November 18, 2026
ingress-nginx controllerAffected (retired in March 2026)No fix planned

Not affected by CVE-2026-123007: NGINX 1.9.4 and earlier, builds without the HTTP/2 module, and servers with HTTP/2 turned off.

Two notes to consider when assessing your servers:

  • The version string can hide a backported fix. Ubuntu 22.04 reports 1.18.0 no matter how many security updates it has. Compare the full package version with your distribution's advisory.
  • A reload doesn't apply the patch. Restart NGINX or do a live binary upgrade after installing it.

NGINX2root severity score unpacked

  • F5 (CNA): CVSS v4.0 base score 9.2 (Critical) for each of the five
  • NVD: not yet assigned

Scoring factors:

  • Reachable over the network
  • No authentication required
  • No user interaction required
  • High attack complexity: each flaw needs a specific configuration

What slows exploitation: the exploit has to shape heap memory precisely, and according to Stephen Fewer, it needs roughly 128 GB of network traffic and a specific AVX-512 memcpy fast path.

The TL;DR for leadership: NGINX servers with HTTP/2 on, running 1.9.5 through 1.31.8 without a backported fix, are exposed to unauthenticated remote code execution, and a separate kernel bug can turn that into root on the host. Upgrading NGINX closes it, and disabling HTTP/2 buys time for two of the five flaws.

NGINX2root disclosure timeline

DateEvent
October 11, 2026Xint discovers the vulnerabilities
October 16, 2026Xint reports them to F5 through HackerOne
October 27, 2026Reports reach F5's NGINX development team
November 10, 2026Xint completes patch validation
November 18, 2026F5 releases NGINX 1.30.7 and 1.31.9; Xint publishes its write-up
November 18, 2026 We add NGINX2root detection to the Network Vulnerability Scanner
November 19, 2026We launch this free NGINX2root scanner

Use our free NGINX2root checker

NGINX2root exploitation - how attackers could use these NGINX vulnerabilities

  • No credentials required: yes

  • No user interaction required: yes

  • Remotely exploitable: yes, when the matching configuration is reachable (for CVE-2026-123007, HTTP/2)

  • Demonstrated: Xint ran CVE-2026-123007 against public IP addresses on AWS, GCP, and Azure, and validated the other four in lab setups. It omits the final exploit steps.

  • Public proof-of-concept: Rapid7 reports one on GitHub

  • Exploited in the wild: no reports as of November 18, 2026

  • CISA KEV: not listed as of November 18, 2026

If exploitation succeeds, an attacker can:

  • Run commands as the NGINX worker

  • Escalate to root through the kernel SCTP bug, including from inside a container

  • Read the traffic the worker decrypts, and reach the backends behind it

How to spot attempts: the attack leaves little in access logs, because the HTTP/2 control frames it uses aren't logged as requests. Xint suggests watching for long-lived connections from one IP that keep receiving data while NGINX sends little back, many short TLS connections from the same source, programs started by an NGINX worker, and repeated worker crashes (signal 11).

How to mitigate NGINX2root

  1. Complete fix: upgrade to NGINX 1.30.7 or 1.31.9 (Plus: 37.0.8.1 or 37.3.0.1), then restart NGINX. A reload doesn't replace the running binary. The fix covers all five flaws.
  2. Upgrade path:
    • Distribution packages: watch your distribution's advisory and compare the full package version, not nginx -v.
    • Official Docker images: pull the updated tag and redeploy.
    • Alpine: upgrade to 1.30.7-r0.
    • OpenResty: watch for a release based on NGINX 1.31.9.
    • ingress-nginx: it's retired with no fix planned, so plan a migration.
  3. Verification: on each host, run nginx -v, check for the HTTP/2 module with nginx -V 2>&1 | grep -- --with-http_v2_module, look for http2 in the configuration with nginx -T, and test from outside with openssl s_client -connect HOST:443 -alpn h2. Then rescan with this scanner.
  4. Temporary controls, per flaw:
    • CVE-2026-123007 and CVE-2026-123633: disable HTTP/2 (http2 off; on 1.25.1 and later, or remove http2 from the listen directive).
    • CVE-2026-123634: point proxy_pass at a fixed upstream group, and turn off mirror where you don't need it.
    • CVE-2026-121810: remove the QUIC/HTTP/3 listeners.
    • CVE-2026-113425: bind the mail proxy to loopback or restrict it with a firewall.
  5. The root chain: on hosts that don't use SCTP, block the kernel module with install sctp /bin/false in a file under /etc/modprobe.d/ until a kernel fix ships.
  6. Closing note: disabling HTTP/2 covers two of the five flaws. Only the upgrade removes all of them.

Get your free NGINX2root scan report

About our Network Vulnerability Scanner

Our Network Vulnerability Scanner is a well-rounded tool for all your network security assessments.

It combines multiple engines and fine-tuned scan settings that surface more than 17,500 vulnerabilities, misconfigurations, and outdated services. Each scan automatically updates your attack surface.

See what else it can do

NGINX2root FAQs

What is NGINX2root?

NGINX2root is a set of five memory safety flaws in NGINX, found by Xint and fixed on November 18, 2026. The most widespread, CVE-2026-123007, affects every NGINX release with HTTP/2 enabled from 1.9.5 through 1.31.8 and can lead to unauthenticated remote code execution.

How does the NGINX2root scanner work?

It reads the NGINX version your server reports and checks whether it negotiates HTTP/2 over cleartext TCP, the two conditions behind CVE-2026-123007 and CVE-2026-123633.

It never sends the attack traffic, because that could crash the server.

The scan couldn't read my NGINX version. Am I safe?

We can't tell. Hiding the version (server_tokens off) is good practice, and it means you need to check on the host with nginx -v.

My server reports nginx/1.18.0 (Ubuntu). Is it vulnerable?

The version alone can't tell you. Ubuntu backports fixes without changing the version NGINX reports, so compare the full package version with Ubuntu's security notices.

As of November 18, 2026, Ubuntu hadn't shipped a fixed package yet.

Does disabling HTTP/2 protect me?

Partly. It blocks CVE-2026-123007 and CVE-2026-123633, but not the other three NGINX2root flaws.

Use it to buy time, and upgrade when you can.

I run NGINX behind a CDN. Am I covered?

Not necessarily. The scan tests whatever answers on the target, which may be the CDN, not your NGINX. Scan or check the origin server directly.

Is ingress-nginx affected?

Yes, and the project is retired with no fix planned. Plan a migration to a maintained ingress controller.

Where does the "root" in NGINX2root come from?

From a separate Linux kernel bug in SCTP. Xint chained it with CVE-2026-123007 to go from the NGINX worker to root on the host, including from inside a Docker container.

Until a kernel fix ships, block the SCTP module on hosts that don't use it.

Why are you offering a free scanner for NGINX2root?

Every day, our team develops tools, detections, and exploits to help security professionals find vulnerabilities before attackers can exploit them.

We know the fight is unfair: security teams follow strict rules, while threat actors do whatever they want. That's why we build free tools like this one, so security teams can validate their exposure quickly, without waiting for a scheduled scan or a costly engagement.

Read more in our vulnerability research manifesto.