Thank You For Reaching Out To Us
We have received your message and will get back to you within 24-48 hours. Have a great day!
Skip to content

NGINX2Root: 5 critical nginx vulnerabilities – what businesses should check now

NGINX2Root: five critical nginx flaws (CVE-2026-123007 and four more) allow unauthenticated code execution. How to check your servers, upgrade to 1.30.7 and reduce exposure.
8 min read

On November 18, 2026, F5 released fixes for five memory-safety flaws in nginx, collectively nicknamed NGINX2Root. Each one can let an attacker run commands on the server without logging in. The most widespread, CVE-2026-123007, only needs HTTP/2 enabled — a very common setup — and public proof-of-concept exploit code already exists.

Quick summary:

  • Affected: nginx Open Source 1.9.5 through 1.31.8 (range varies by flaw), and NGINX Plus from R33 and 37.0.0.
  • Fixed in: nginx 1.30.7 (stable) and 1.31.9 (mainline), or your OS vendor's patched package once released.
  • Can't patch yet? Disabling HTTP/2 blocks two of the five flaws; the other three need their own mitigations.
  • After upgrading, restart nginx — a reload is not enough.

What happened?

nginx is the web server and reverse proxy in front of more than 225 million websites, according to Netcraft figures cited by Wiz. It sits at the front door: it accepts HTTPS connections, decrypts them and forwards requests to the applications behind it. All five flaws live in that front-door code, so they can be reached before any application logic or login runs.

The Xint team found all five in October 2026 and reported them to F5 via HackerOne. The two HTTP/2 flaws were also found independently by Wiz Research, Rapid7, Metnir and Ikotas Labs. F5 shipped the fixes on November 18, 2026, under coordinated disclosure.

F5 rates all five 9.2 out of 10 on CVSS 4.0 (Critical). Notably, the code behind CVE-2026-123007 arrived with HTTP/2 in nginx 1.9.5 back in 2015 — more than ten years ago. Both Wiz and Xint say AI-assisted code scanning helped them find the bugs.

At the time of writing, no exploitation in the wild has been reported and the flaws are not on CISA's KEV list. However, Rapid7 and other researchers have published proof-of-concept code for CVE-2026-123007, so the safe window is closing fast.

The 5 flaws in plain language

Each flaw is an independent attack path; they do not need to be chained. What differs is the configuration: your server is only exposed if it uses the matching feature.

Architecture diagram: the five NGINX2Root flaws sit in four nginx entry points (HTTP/2, HTTP/3, DNS resolver, mail proxy), with the path to root via the Linux kernel SCTP flaw
Architecture diagram: the five NGINX2Root flaws sit in four nginx entry points (HTTP/2, HTTP/3, DNS resolver, mail proxy), with the path to root via the Linux kernel SCTP flaw

All five flaws sit in code nginx runs before a request reaches the application; exploited and chained with the kernel SCTP flaw, they can give an attacker root on the whole host.

1. CVE-2026-123007 — a counter that "wraps around" in HTTP/2

HTTP/2 keeps a counter of how much data may still be sent. By cancelling requests at just the right moment, an attacker pushes this counter past its limit until it wraps into a huge number. nginx believes there is plenty of room and copies data outside the allowed memory, leaking memory and potentially running attacker code. Wiz achieved code execution on 1.31.7 and 1.31.8 serving only static files, with no backend at all.

CVE-2026-123007 attack flow in five steps: the HTTP/2 send-window counter is pushed past its limit and wraps
CVE-2026-123007 attack flow in five steps: the HTTP/2 send-window counter is pushed past its limit and wraps

The crux is the moment the counter passes its limit: from then on, nginx's bounds check no longer stops anything.

2. CVE-2026-123633 — "keeping the room key" in HTTP/2 proxying

When free connection slots run low, nginx closes an HTTP/2 connection to free one — while a request on that connection is still in use. It is like checking out of a hotel but keeping the key: freed memory is still accessed, and an attacker can plant their own data there (a use-after-free).

The use-after-free bug pattern in four steps, explained as checking out of a hotel but keeping the key
The use-after-free bug pattern in four steps, explained as checking out of a hotel but keeping the key

Four of the five flaws are variants of this pattern; they differ only in where nginx frees memory too early.

3. CVE-2026-121810 — the same pattern in HTTP/3

HTTP/3 is the newer protocol running over QUIC (UDP). The bug triggers when a QUIC connection is closed mid-request while that request is being forwarded to a backend.

4. CVE-2026-123634 — a flaw in nginx's own DNS lookups

When nginx resolves a hostname while handling a request, a failed lookup combined with a client reset can make it use memory that has already been freed.

5. CVE-2026-113425 — a flaw in the mail proxy

nginx can sit in the middle and relay mail. If a client resets the connection during login, its session is freed while still referenced. No valid credentials are needed.

Am I affected? Quick reference

CVEComponentAffected configurationAffected OSS versionsBlocked by disabling HTTP/2?
CVE-2026-123007HTTP/2HTTP/2 enabled (listen 443 ssl http2; or http2 on;)1.9.5 – 1.31.8Yes
CVE-2026-123633HTTP/2HTTP/2 enabled and requests forwarded to an upstream1.19.7 – 1.31.8Yes
CVE-2026-121810HTTP/3 (QUIC)HTTP/3 enabled (listen ... quic; / http3 on;) and proxyingfrom 1.25.0No
CVE-2026-123634DNS resolverresolver, a proxy_pass with a variable (resolved at request time) and a subrequest such as mirror (or SSI)from 0.6.18No
CVE-2026-113425Mail proxyA mail block with proxy on; and auth_httpfrom 0.5.33No

Version ranges as compiled by Equixly from nginx.org; all are fixed in 1.30.7 and 1.31.9.

Why it matters for your business

A successful attack runs commands as the nginx worker process. That process decrypts all HTTPS traffic, so cookies, login tokens and API keys for every site and API behind it pass through its memory. However well your application is written, it is exposed if the front door falls.

The risk grows when combined with an unpatched flaw in the Linux kernel's SCTP module (since 4.15). Xint used this chain to escape a Docker container and gain root on the AWS host. Because containers share the host kernel, root on the host means control of every container on it.

Three factors make these flaws harder to defend against than usual:

  • Very widespread: Xint counted 56.7 million nginx hosts on Shodan; 98.9% of those showing a version fall in the CVE-2026-123007 range (the real number is lower, since HTTP/2 must be on and backported fixes count).
  • Hard to detect: the frames used in the attack are not requests, so they don't appear in access logs, and TLS hides them on the wire.
  • ASLR doesn't help: the attacker reads memory first and only then overwrites it, defeating address randomization.

Check your servers in 5 minutes

  1. Check the version and package. nginx -v gives a first cut. If nginx came from Ubuntu, Debian or Red Hat, check the full package version (e.g. dpkg -l nginx), because fixes are often backported while nginx -v still prints the old number.
  2. Check whether the build includes HTTP/2. nginx -V 2>&1 | grep -c http_v2_module returns 0 when the binary has no HTTP/2 code.
  3. Check the running configuration. nginx -T prints the full config. Look for:
    • http2 in a listen line or http2 on; → CVE-2026-123007, CVE-2026-123633
    • quic or http3 on; → CVE-2026-121810
    • resolver with a variable in proxy_pass, plus mirror → CVE-2026-123634
    • a mail block with auth_http → CVE-2026-113425
  4. Test from outside. openssl s_client -connect HOST:443 -servername HOST -alpn h2 reports ALPN protocol: h2 when the server accepts HTTP/2. Behind a CDN, also test the origin directly.
  5. Don't forget "hidden" nginx. Kubernetes ingress controllers, Docker images, appliances and packaged software that bundle nginx also need checking and updating per vendor.

How to fix it

Priority one: upgrade. Move to nginx 1.30.7 (stable) or 1.31.9 (mainline); both fix all five flaws. For NGINX Plus, CVE-2026-123007 is fixed in 37.0.8.1 and 37.3.0.1, and CVE-2026-123633 in 37.0.7.1 and 37.2.0.1; R33 to R36 get no fix.

The official nginx Docker images and Alpine 3.24 already ship the fix. Ubuntu, Debian and Red Hat had not released patched packages as of November 18; if you rely on your OS package, consider switching to the nginx.org repository or disabling HTTP/2 while you wait.

After moving to 1.30.7, check all six points before calling it done:

  1. Restart, don't just reload. A reload only re-reads the config; old workers keep running vulnerable code until they exit. Alternatively, do a live binary upgrade.
  2. Confirm the running version. nginx -v must report 1.30.7 (or an OS package whose advisory lists the five CVEs), with no old worker processes left (ps aux | grep nginx).
  3. Update every place nginx runs. Pull the new image and redeploy containers, rebuild your own images, and update ingress controllers and products that bundle nginx per vendor. Images pinned to old digests stay vulnerable. Internet-facing servers first.
  4. Rebuild dynamic modules. Separately built modules (e.g. ModSecurity, GeoIP2) must be rebuilt for 1.30.7, or nginx will refuse to start.
  5. Block the kernel SCTP module. The SCTP flaw used to escalate to root has no patch yet, and upgrading nginx does not address it. On hosts that don't use SCTP, add install sctp /bin/false to a .conf file in /etc/modprobe.d/.
  6. Re-enable HTTP/2 if you turned it off, once 1.30.7 is confirmed running.

Can't upgrade right away? Reduce exposure:

ConfigurationTemporary mitigationCovers
HTTP/2 enabledOn 1.25.1+: set http2 off; in every server block and remove http2 from listen; older releases: remove http2 from listenCVE-2026-123007, CVE-2026-123633
HTTP/3 + proxyingRemove quic listeners, set http3 off;, send Alt-Svc 'clear', block UDP on that portCVE-2026-121810
resolver + variable proxy_pass + mirrorPoint proxy_pass at a fixed upstream group; turn off mirror where not neededCVE-2026-123634
Mail proxy with auth_httpBind to loopback, or allow only trusted IPs at the firewallCVE-2026-113425
Hosts not using SCTPAdd install sctp /bin/false to a .conf file in /etc/modprobe.d/Kernel step to root

After any config change, run nginx -t, reload, and restart if old workers still hold connections. Re-enable HTTP/2 once the fixed release is running.

Watch for warning signs: an nginx worker spawning a shell or any other program is the strongest signal (record it with an auditd rule on execve). Weaker signs: long-lived HTTP/2 connections with steadily climbing received bytes, many short TLS connections from one source, and repeated worker crashes (signal 11 in the error log).

The lesson: systems must be operated, not just built

NGINX2Root is the third critical infrastructure-level flaw disclosed in a single week, after an Apache HTTP Server HTTP/2 bug and a Java flaw. The common thread: the bugs sit in underlying software few people watch, not in application code. As AI speeds up vulnerability discovery, exploits appear faster too, and the gap between disclosure and attack keeps shrinking.

Beyond this patch, businesses need a standing process: an inventory of servers and software, a channel for security alerts, and a named owner who applies updates within days.

Haposoft helps businesses review nginx configurations, apply patches and put mitigations in place across servers, Docker, Kubernetes and AWS. Contact us at contact@haposoft.com.

References

Share
Copied
cta-background

Subscribe to Haposoft's Monthly Newsletter

Get expert insights on digital transformation and event update straight to your inbox