NGINX2Root is five memory-safety bugs in nginx that is fixed in 1.31.9 and 1.30.7 since 18 November 2026. If HTTP/2 is on, you are exposed to CVE-2026-123007 on every release from 1.9.5. Install the fixed build, and don’t forget to restart nginx. A reload keeps the old binary running. None of the five CVEs are in CISA KEV (catalog 2026.11.18). I spent a day before this blog release analyzing the nginx source, the F5 advisories, 50 GitHub repositories and a four-target lab. Most of what is out there repeats the advisory.
However, one of the five bugs was fixed in code before being discovered. The fix for CVE-2026-123633 was written on 17 September 2026 and credited to another researcher. Xint, who named the set, says it discovered the bugs on 11 October. The fix then sat for two months.

This is how I got there, what I would patch first, and what I would watch while you patch:
CVE-2026-123007: HTTP/2 flow control
- HTTP/2 enabled on any listener
- Affected from 1.9.5 (2015) to 1.31.8
- Code execution needs an ASLR bypass
Patch now
Fixed in 1.31.9 and 1.30.7. Workaround: http2 off.
Public exploit (Rapid7)
CVE-2026-123633: HTTP/2 connection reuse
- HTTP/2 plus proxying to a backend
- Worker must be low on worker_connections
- Affected from 1.19.7 (2021)
Patch now
Fixed in 1.31.9 and 1.30.7. Workaround: http2 off.
No public exploit
CVE-2026-121810: HTTP/3 connection reuse
- HTTP/3 plus proxying to a backend
- Worker must be low on worker_connections
- Affected from 1.25.0 (2023)
Patch
Fixed in 1.31.9 and 1.30.7. Workaround: remove QUIC listeners.
No public exploit
CVE-2026-123634: resolver
- resolver plus proxy_pass built from variables
- SSI or mirror subrequest resolving the same name
Patch
Fixed in 1.31.9 and 1.30.7. Workaround: fixed upstream names.
No public exploit
CVE-2026-113425: mail proxy
- Mail proxy with auth_http
- Rare in web deployments
Patch
Fixed in 1.31.9 and 1.30.7. Workaround: bind mail listeners to trusted networks.
No public exploit
Patch, then restart. After installing the fixed package, nginx -s reload starts new workers from the old binary that is still in memory. Only a full restart, or a live binary upgrade, runs the fixed code. Check with ls -l /proc/$(cat /run/nginx.pid)/exe: if it says (deleted), the old binary is still running.
Which nginx versions and F5 products are affected?
Patch to nginx 1.31.9 (mainline) or 1.30.7 (stable). Both fix all five. Where people disagree is when each bug started: F5 and Xint give different first versions for two of them, so I went to the nginx Git history to settle it.
| CVE ID | Component | Affected Versions | Git Information | nginx.org rating |
|---|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow control | 1.9.5 | HTTP/2 first shipped in 1.9.5 | major |
| CVE-2026-123633 | HTTP/2 connection reuse | 1.19.7 | Commit 76672e65 (11 Feb 2021) first shipped in 1.19.7 | medium |
| CVE-2026-121810 | HTTP/3 connection reuse | 1.25.0 (the CVE record says “1.25.09”) | HTTP/3 first shipped in 1.25.0 | medium |
| CVE-2026-123634 | resolver | 0.6.18 | 0.6.18 is the first release where proxy_pass with variables resolves names; 1.13.4 is the release that added the mirror module | medium |
| CVE-2026-113425 | mail proxy | 0.5.33 | The mail proxy module first shipped in 0.5.15 | major |
NGINX Plus and the rest of the F5 NGINX family
The F5 articles split the NGINX Plus fixes. 37.2.0.1 and 37.0.7.1 fix only CVE-2026-123633. The other four need 37.3.0.1 or 37.0.8.1. The mail proxy article (K000163931) prints 37.3.0 and 37.0.8 without the trailing .1, unlike the other four. I would treat 37.3.0.1 and 37.0.8.1 as the target until F5 clarifies.
| Product | Branch | Fixed in | No fix offered for |
|---|---|---|---|
| NGINX Plus | 37.x | 37.3.0.1, 37.0.8.1 (37.2.0.1 and 37.0.7.1 cover 123633 only) | R34 to R36 |
| NGINX Instance Manager | 2.x | 2.25.0 | |
| F5 WAF for NGINX | 5.x | 5.16.2, 5.14.4 | |
| F5 DoS for NGINX | 4.x | 4.13.0 | |
| NGINX Gateway Fabric | 2.x | 2.9.0 | 1.5.0 to 1.6.2 |
| NGINX Ingress Controller | LTS, 5.x | 2026-lts-r11, 5.8.0 | 4.0.0 to 4.0.1, 3.7.1 to 3.7.2 |
| NGINX App Protect WAF | 5.x, 4.x | 5.4.0 to 5.8.0, 4.12.0 to 4.16.0 | |
| NGINX App Protect DoS | 4.x | 4.5.0 to 4.7.0 | |
| F5 Distributed Cloud, NGINX One Console | Still under review for four CVEs; “not vulnerable” for 113425 |
The F5 umbrella article lists only NGINX Plus and NGINX Open Source as affected by CVE-2026-123007. The CVE-2026-123007 article itself lists all of the products above. Trust the per-CVE article.
What is the root cause of CVE-2026-123007?
Root cause in simple terms nginx loses track of how much data it is allowed to send. The bug has been in the HTTP/2 module since it first shipped in 1.9.5 in 2015. HTTP/2 has flow control. The client tells the server how many bytes it may send, and raises that limit with WINDOW_UPDATE frames. nginx keeps a per-connection send window and checks every WINDOW_UPDATE so the window never goes above NGX_HTTP_V2_MAX_WINDOW, the protocol maximum.
Here is the gap, in the words of the fix commit. When a stream is cancelled, nginx gives the bytes of its unsent DATA frames back to the connection window. If the client raised the window after those frames were queued, the refund pushes the window past the maximum. The WINDOW_UPDATE check never counted the queued bytes, so it could not see this coming. From there the buffer size logic in ngx_http_v2_send_chain() breaks, and nginx writes past the end of a heap buffer.
The fix adds a send_queued counter and includes it in the WINDOW_UPDATE check:
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {
It shipped as two commits with the same message: e27f5fa8 on mainline (1.31.9) and b89c4100 on stable (1.30.7). Both were written on 29 October 2026 and credit Xint.io. You will see this bug called an integer underflow, an overflow and an out-of-bounds write, depending on whose write-up you read. They all describe the same chain from different ends: the window goes past its upper limit, then a later length calculation wraps. I stick with the CVE record’s labels, CWE-191 and CWE-787, because those are what your scanner and ticketing system will match on.
This is the one I would patch first. The only precondition is HTTP/2 on a listener: no proxying, no special modules, no backend. Two teams already have code execution. Rapid7 published its exploit on 18 November. Wiz showed an ASLR bypass against the official 1.31.7 and 1.31.8 builds and is keeping its exploit private. I did not run either.
Why are CVE-2026-123633 and CVE-2026-121810 the same bug?
Same failure, two transports: nginx frees a connection that still has a live request on it. Aikido spotted the pattern first and deserves the credit. What I can add is how the two fixes differ, because that tells you which log line to watch.
The mechanism they share
When a worker runs short of free connections, nginx calls ngx_drain_connections(). That function closes connections marked “reusable”, meaning idle ones that no request is using. It logs one line at warn level when it does this:
%ui worker_connections are not enough, reusing connections
Both bugs leave a busy connection marked reusable. When the worker is under connection pressure and the request is waiting on its upstream, the drain closes the connection and frees its memory pool. The request code then keeps using that freed memory.
CVE-2026-123633: HTTP/2 never cleared the flag
In February 2021, commit 76672e65 made an HTTP/2 connection reusable when it held only a partial frame and no streams. The goal was to stop slow clients from tying up connections. It shipped in 1.19.7.
The fix commit explains the side effect. If a client sends only the first byte of a HEADERS frame, the connection becomes reusable. When the rest of the frame arrives and nginx creates a stream, nothing resets the flag. The connection stays reusable for as long as the stream runs. The fix is two lines in ngx_http_v2_create_stream():
ngx_reusable_connection(h2c->connection, 0);
CVE-2026-121810: QUIC cleared the flag, then lost it again
The QUIC code already cleared the flag when it created a stream. The bug is in the order of operations. Per fix commit b5252dae, ngx_quic_create_stream() cleared the flag, then called ngx_get_connection() before it put the new stream into the stream tree. If the worker was short of connections, the drain inside that call could close an idle stream of the same QUIC connection. With the new stream not yet in the tree, nginx saw no streams left and marked the main connection reusable again. The fix inserts the stream into the tree first.
What this means for you
The two bugs need the same conditions: a reverse proxy, and a worker low on worker_connections. So the same log line is your best early signal for both. If your error log never shows worker_connections are not enough, an attacker has to create that pressure first, and that takes a lot of connections from somewhere. It is not proof you are safe. It is a good place to start counting.
Raising worker_connections is not a fix, but it makes both bugs harder to reach. The attacker has to fill more connection slots before the drain runs.
Who found CVE-2026-123633 first?
Based on the Git history, this is what I see:
| Date | Event | Source |
|---|---|---|
| 17 Sep 2026 | Fix for 123633 written, credited to “Albert @ Vexera AI” (commits 2df48a50 mainline, 0c87dd1d stable) | nginx Git author date |
| 11 Oct 2026 | Xint discovers all five bugs | Xint |
| 16 Oct 2026 | Xint reports to F5 through HackerOne | Xint |
| 21 Oct 2026 | Wiz reports 123633; F5 says another team reported it first | Wiz |
| 11 Nov 2026 | All fix commits land; 1.31.9 and 1.30.7 tagged | nginx Git commit dates |
| 18 Nov 2026 | Release, advisories and CVE records | nginx.org, F5 |
What about the resolver and mail proxy bugs?
Both need a configuration that most web servers do not have. Check for it, patch anyway, and move on.
| CVE-2026-123634 (resolver) | CVE-2026-113425 (mail proxy) | |
|---|---|---|
| Bug class | Use-after-free, CWE-416 | Use-after-free, CWE-416 |
| You are exposed if | resolver is set, proxy_pass builds its target from variables, and an SSI or mirror subrequest resolves the same name | a mail block uses auth_http, with proxy on per Xint |
| What goes wrong (fix commit) | A resolve handler finalises another pending resolve of the same name; nginx then reports the freed one. Fix e39708ed, credited to Xint.io | The client resets the connection while the auth_http request is running; the send failure destroys the session that auth_http still points to. Fix 754fe68c, credited to Xint.io |
| Find it | nginx -T | grep -nE 'resolver|proxy_pass +https?://[^;]*\$|mirror|ssi on' | nginx -T | grep -nE '^\s*mail\s*\{|auth_http' |
| Workaround (F5) | Avoid SSI and mirror, and do not build proxied server names from variables | Restrict mail listeners to trusted networks |
| nginx.org rating | medium | major |
The commit-to-CVE mapping is mine. No commit message names a CVE. I matched them by subsystem, by the CVE description and by the Xint credit. For the mail bug, three more commits in the same release (“Mail: blocked client writes …”) harden nearby code and carry no reporter line. I do not know whether F5 counts them as part of 113425.
Turning HTTP/2 off does nothing for these two, or for the HTTP/3 bug. It only covers CVE-2026-123007 and CVE-2026-123633.
How does an attacker get from an HTTP/2 connection to root?
In five steps, and you can break or see four of them.
What has to be true for the bug to be reachable?
Four conditions apply to every HTTP/2 and HTTP/3 bug in this set. CVE-2026-123633 and CVE-2026-121810 add two more.
How hard is it to get code execution with CVE-2026-123007?
Really speaking, it is hard to do at scale, but nothing can stop a persistent attacker against one target. However, there are a lot of detection avenues and timing based opportunities. Here is what the one public exploit, costs an attacker:
Traffic on one HTTP/2 connection
Time to send 128 GB
What stands in the way of a real world exploit:
- Connection volume: Each WINDOW_UPDATE frame is 13 bytes and adds a bounded amount of credit, so the exploit needs billions of them. It all has to go down one connection.
- Time limit: nginx closes a connection after one hour by default (
keepalive_time). Below roughly 300 Mbit/s, the attacker runs out of time before the exploit finishes. - Hardware: The exploit relies on a specific glibc
memcpyvariant on CPUs with AVX-512. A server with a different CPU or C library copies memory differently, and the exploit’s assumptions break. - Heap: Rapid7 says the exploit is built for a freshly started container and will likely fail against a busy server.
- Worker only privileges: Success gives code execution as the nginx worker user. Root needs a second exploit, such as the SCTP kernel bug Xint used.
These limits belong to Rapid7’s exploit, not to the bug. Wiz has its own working exploit against the official 1.31.7 and 1.31.8 builds, ASLR bypass included, and has not published it. Xint has a third. Do not read “needs 128 GB” as “safe”.
So if you ask me, spraying the internet with Rapid7’s exploit is expensive: bandwidth, a one-hour window on one connection, and a target whose CPU and heap match. Knocking workers over is cheaper, at about half the traffic. But an attacker with a 10 Gbit/s link, a private exploit like Wiz’s or Xint’s, and one valuable server that uses HTTP/2 straight to the internet does not care about any of that. That server is the one I would fix first.
When was each bug reported and fixed?
The CVE-2026-123633 fix was written 62 days before release. The CVE-2026-123007 bug was in the code for 11 years.
Two releases shipped while these reports were open. nginx 1.31.7 and 1.30.6 came out on 14 October, and 1.31.8 on 21 October. None of them carries these fixes. If your team patched to 1.31.7 or 1.31.8 last month, you are still exposed. Look at the credits and you see how crowded these bugs were. F5 thanks four teams for CVE-2026-123007 (Rapid7, Wiz, Xint and Ikotas Labs, which calls it NGINX2Shell) and four for CVE-2026-123633 (Metnir, Wiz, Xint and Unit 42). When that many people land on the same bugs within weeks, I assume someone who does not file reports got there too.
How do you detect NGINX2Root exploitation?
Watch the connection volume and the worker process. The access log will not help: the frames that trigger CVE-2026-123007 are control frames, not requests, so they never reach it. I checked every log string below against the nginx 1.31.9 source. None of the rules has been tested against live exploit traffic.
Log lines that exist in nginx
| What to check? | Exact string (nginx source) | Level | When to check? |
|---|---|---|---|
| Blocked 123007 attempt | client violated connection flow control: received WINDOW_UPDATE frame with window increment %uz not allowed for window %uz | info | On 1.31.9 and 1.30.7 the check counts queued bytes, so an attempt trips it. Unpatched builds have the same check without the queued bytes, and the exploit is built to pass it. You need error_log ... info; to see it |
| Precondition for 123633 and 121810 | %ui worker_connections are not enough, reusing connections | warn | Any build, whenever the drain runs. Rare on a healthy server |
| Crash, failed attempt or heap grooming | %s %P exited on signal %d (for example worker process 4242 exited on signal 11) | alert | Any build |
# Read-only triage. Adjust the log path.
grep -E 'exited on signal (6|7|11)|worker_connections are not enough|violated connection flow control' /var/log/nginx/error.log*
coredumpctl list nginx 2>/dev/null
journalctl -k | grep -i 'segfault.*nginx'
lsmod | grep -w sctp
Network: one connection, a lot of client bytes
The exploit pushes tens of gigabytes from the client to the server on one TLS connection, with almost nothing coming back. Normal browsing looks the opposite way round. This Zeek one-liner pulls those sessions out of conn.log:
# Long sessions to 443 where the client sent more than 5 GB and 20 times what it received
zeek-cut ts id.orig_h id.resp_h id.resp_p duration orig_bytes resp_bytes < conn.log \
| awk '$4==443 && $5>60 && $6>5e9 && $6>20*($7+1)'
On the host, ss -tni state established '( sport = :443 )' shows bytes_received per connection. One peer with a fast-growing counter and a long-lived connection is worth a look. Large uploads will match too, so check the URL in the access log before you escalate.
Host: the worker should never start a shell
nginx workers do not start programs in a normal setup. Any execve from the worker user is worth an alert.
# auditd. Debian and Ubuntu run workers as www-data (uid 33). On RHEL, check: id -u nginx
-a always,exit -F arch=b64 -S execve,execveat -F euid=33 -k nginx_worker_exec
Sigma rules to detect
- Shell or Downloader Started by an nginx Worker – https://github.com/mayur-esh/sigma-rules/blob/main/generic/CVE-2026-123007.yml
Which mitigations work, and what do they cost you?
Patching is the only fix. Everything else narrows one path and has a price.
| Action | Covers | Operational Impact | How to verify |
|---|---|---|---|
| Install 1.31.9 or 1.30.7 (or the vendor package that carries the fix), then restart | All five | A restart drops every open connection, so expect a short blip. A live binary upgrade (kill -USR2, then -QUIT the old master) avoids that | ls -l /proc/$(cat /run/nginx.pid)/exe must not say (deleted); nginx -v shows the fixed version |
http2 off; in each server block (1.25.1 and later), or remove http2 from listen (earlier releases) | CVE-2026-123007, CVE-2026-123633 | Clients fall back to HTTP/1.1: more connections per client and slower pages with many assets. gRPC over HTTP/2 stops working | openssl s_client -alpn h2 -connect host:443 </dev/null 2>/dev/null | grep ALPN shows no h2 |
Remove QUIC listeners, http3 off;, send Alt-Svc: clear | CVE-2026-121810 | Clients lose HTTP/3 and fall back to HTTP/2 | No quic in nginx -T; no h3 in Alt-Svc |
| Fixed upstream names; no SSI or mirror where a variable picks the target | CVE-2026-123634 | Breaks dynamic routing that relies on proxy_pass http://$var | nginx -T review |
| Bind mail listeners to trusted networks | CVE-2026-113425 | Remote mail users need a VPN or another path | ss -ltn shows no public 25, 110, 143, 465, 587, 993, 995 |
Lower keepalive_time (default 1h), for example to 10m | Raises the bar for the public 123007 exploit [Likely] | More TLS handshakes for long-lived clients | nginx -T | grep keepalive_time |
install sctp /bin/false in a file under /etc/modprobe.d/ | Xint’s root step | Breaks anything that uses SCTP. It does not unload a module that is already loaded, and does nothing if SCTP is built into the kernel | lsmod | grep -w sctp is empty after a reboot |
Reload and restart do different jobs. A reload is enough for a configuration change such as http2 off;, but old workers keep their existing connections until those close, so confirm the old workers have exited. A restart is needed for a new binary. A reload starts new workers from the old binary.
The keepalive_time row is my own suggestion, from reading the source. In ngx_http_v2_state_headers(), once a connection is older than keepalive_time, nginx sends GOAWAY and refuses new streams. The public exploit needs a steady supply of new streams on one connection. With keepalive_time 10m;, pushing 128 GB in time needs about 1.7 Gbit/s instead of about 300 Mbit/s. I have not tested this against the exploit. It does nothing for a crash that needs less traffic, and it is not a patch.
Which public NGINX2Root repositories can you trust?
On the first day, the only repository with real attention was an exploit, and the best defensive tools had one star each. I ran the same repository reliability score I used for PHP2Shell: a safety status for every repository, and a score out of 100 for defensive ones (50 content, 30 provenance, 20 hygiene), compared only within a class.
NGINX2Root repositories by inclusion tier
Safety status
Safety status, all 50 repositories
| Repository Name | Status | Reason |
|---|---|---|
| WormW/nginx2root-rce-lab | Caution | Staged history: all 6 commits have a seconds value of 00, and the first is dated 3.5 hours before the repository was created |
| Coff0xc/cofflab | Caution | Aggregator; vendors Rapid7’s full exploit tree and carries 2 archives |
| yancey918/check_nginx2root | Caution | README tells you to pipe its raw script from GitHub into bash |
| flash-orange-afk/nginx-armhf-security-build | Caution | Prebuilt nginx archive; it ships SHA256SUMS, so check them before use |
Two copies on the exploit side: farruhilhamov/Nginx2Root is a file-for-file mirror of arkrwn’s Rust exploit, and akarkode’s lab reuses Rapid7’s streamer.c. I found no copying between the defensive tools.
What the lab showed
I built three nginx binaries from source: 1.31.8 (vulnerable), 1.31.9 (patched), and 1.31.9 back-patched to report 1.31.8, which is what a distribution package with a back-ported fix looks like. The network probes also got a fourth target, 1.31.9 with server_tokens off. Each scanner ran as an unprivileged user in a network namespace with only loopback. No exploit or PoC code ran.
| Scanner | 1.31.8 | 1.31.9 | Back ported | Version hidden | Grade |
|---|---|---|---|---|---|
foxcornlab/nginx-scanner --local | vulnerable | patched | vulnerable | n/a | Partial |
| The-DevOps-Daily/nginx2root-check | vulnerable | patched | vulnerable | n/a | Partial |
| xxyyboy/nginx2root-check | affected | safe | affected | n/a | Partial |
| maizarrahman/nginx_cve_2026_audit | risk | ok | risk | n/a | Partial |
| Mahgal/nginx-http2-rce-check | vulnerable | patched | vulnerable | n/a | Partial |
| ashrafzaryouh/CVE-2026-123007 | red | needs package check | red | n/a | Partial |
| TimTheBeastNL/nginx2root (host check) | vulnerable | ok | vulnerable | n/a | Partial |
| TimTheBeastNL/nginx2root (surface probe) | exposed | ok | exposed | asks you to check the host | Banner false positive |
foxcornlab/nginx-scanner --url | vulnerable | clean | vulnerable | error, no verdict | Banner false positive |
| materaj2/cve-2026-123007-scanner | not affected | not affected | not affected | potentially affected | Wrong |
All the “Partial” tools print a warning that distribution packages may carry a fix under the old version number. That is the honest answer for a version check, and it is why none of them earns a full grade. Quaerendir’s audit is the one tool built to read the package changelog for the CVE IDs, but it reads /proc and needs root, so it could not run in my unprivileged lab. The same goes for yancey918’s script, which refuses to run without root, and rogersouzak8s’s local mode, which found no target as a normal user.
Scores by class
| Class | Repository | Score | Class percentile | Lab |
|---|---|---|---|---|
| Scanner | foxcornlab/nginx-scanner | 77.5 | 100 | Partial |
| Scanner | The-DevOps-Daily/nginx2root-check | 74.5 | 91 | Partial |
| Scanner | ashrafzaryouh/CVE-2026-123007 | 70.0 | 82 | Partial |
| Scanner | TimTheBeastNL/nginx2root | 70.0 | 82 | Partial |
| Scanner | maizarrahman/nginx_cve_2026_audit | 70.0 | 82 | Partial |
| Scanner | xxyyboy/nginx2root-check | 70.0 | 82 | Partial |
| Scanner | Mahgal/nginx-http2-rce-check | 65.0 | 45 | Partial; covers the HTTP/2 pair only |
| Scanner | Quaerendir/cve-2026-123633-123007-nginx-audit | 60.3 | 36 | Could not run as non-root |
| Scanner | yancey918/check_nginx2root | 57.0 | 27 | Could not run as non-root |
| Scanner | rogersouzak8s/nginx-http2-check | 55.3 | 18 | Could not run; covers 123007 only |
| Scanner | materaj2/cve-2026-123007-scanner | 20.0 | 9 | Wrong |
| Docs | suominen/CVE-2026-123007 | 85.0 | 100 | Static |
| Docs | Xiaoyuan-114/nginx2root-response-skill | 78.8 | 67 | Static |
| Docs | techtaek77/nginx2root-guide | 60.0 | 33 | Static |
| Patch | bbcreation/nginx2root | 62.8 | 100 | Static |
| Patch | kpirliyev/nginx2root-patcher | 62.8 | 100 | Static |
Scores compare within a class only. A docs repository earns content points for stating facts; a scanner earns them by passing a test. The ranking holds under four other weightings (Spearman 0.97 to 0.99 against 50/30/20).
What have national CERTs said about NGINX2Root?
Do not wait for your national CERT on this one. CERT-EU and Belgium’s CCB published on release day. On the morning of 19 November, CISA and the UK NCSC had nothing out. What I could read mostly repeats F5, and CERT-EU’s notice gets two details wrong. I read two notices; the rest I list as reported by someone else.
| Agency | Notice | Date | Rating | What it says |
|---|---|---|---|---|
| CERT-EU | Security Advisory 2026-022 | 18 Nov 2026 | CVSS 3.1 8.1 for all five | All five can lead to code execution as the worker. Patch internet-facing systems first. Watch for worker crashes and process creation. Disabling HTTP/2 covers 123007 and 123633 only. No exploitation in the wild reported |
| CCB (Belgium) | Warning: Multiple Critical NGINX Vulnerabilities, Patch Immediately! | 18 Nov 2026 | CVSS 4.0 9.2 for each | Patch immediately; refers to F5 for products and versions |
Frequently asked questions
What is NGINX2Root?
NGINX2Root is the name Xint gave to five memory-safety bugs in nginx, disclosed on 18 November 2026: CVE-2026-123007 and CVE-2026-123633 in HTTP/2, CVE-2026-121810 in HTTP/3, CVE-2026-123634 in the resolver and CVE-2026-113425 in the mail proxy. Each can crash a worker, and with an ASLR bypass, run code as the worker user.
Which nginx versions fix NGINX2Root?
nginx Open Source 1.31.9 (mainline) and 1.30.7 (stable) fix all five. NGINX Plus needs 37.3.0.1 or 37.0.8.1; 37.2.0.1 and 37.0.7.1 fix only CVE-2026-123633. Distribution packages often carry the fix under an older version number, so check your vendor tracker, then restart nginx.
Does disabling HTTP/2 protect against NGINX2Root?
Only partly. Turning HTTP/2 off blocks CVE-2026-123007 and CVE-2026-123633. It does nothing for CVE-2026-121810 (HTTP/3), CVE-2026-123634 (resolver) or CVE-2026-113425 (mail proxy). It also breaks gRPC over HTTP/2. Use it as a stopgap on exposed listeners until you can install 1.31.9 or 1.30.7 and restart.
Is NGINX2Root exploited in the wild?
No exploitation in the wild had been reported as of 19 November 2026. None of the five CVEs is in CISA KEV catalog 2026.11.18, and CISA rates exploitation as none. Rapid7 published a working exploit for CVE-2026-123007 on 18 November, so expect that to change.
How much traffic does the CVE-2026-123007 exploit need?
Rapid7 says its public exploit needs about 128 GB of HTTP/2 traffic on one connection: about 2 minutes at 10 Gbit/s or 17 minutes at 1 Gbit/s. It also depends on a glibc memcpy variant on AVX-512 CPUs and a clean heap. Upwind estimates about 60 GB to crash a worker.
Do I need to restart nginx after patching?
Yes. A reload starts new workers from the old binary already in memory, so the vulnerable code keeps running. Restart nginx, or do a live binary upgrade, after installing the fix. A reload is enough for configuration changes such as http2 off, once the old workers have exited.
Leave a Reply
You must be logged in to post a comment.