nginx2root: What Five NGINX RCEs Mean for End-of-Life NGINX
nginx2root is five remote code execution flaws in NGINX, fixed only in 1.30.7 and 1.31.9. See how the HTTP/2 bugs work and which EOL versions stay exposed.

F5 released NGINX 1.30.7 and 1.31.9 on November 18, 2026, fixing five remote code execution vulnerabilities that Xint named nginx2root.
Those are the only two releases with the fixes.
Every other NGINX branch is end of life, and by W3Techs' count that is roughly three out of every four NGINX websites.
Below: how the two HTTP/2 bugs actually work, why every retired branch is in range, and what to do when F5 will not ship a fix for the version you run.
TL;DR
- nginx2root is five unauthenticated remote code execution bugs in NGINX, disclosed November 18, 2026. F5 fixed them in 1.30.7 and 1.31.9, and in no other release.
- CVE-2026-123007 is an integer underflow in HTTP/2 flow control that ends in an out-of-bounds memcpy(). It needs nothing but HTTP/2, and it works against a server serving static files.
- CVE-2026-123633 is a use-after-free: when NGINX runs short of connection slots, it closes an HTTP/2 connection out from under its own request. Any proxy configuration is in range.
- Chained with a Linux kernel SCTP flaw, any of the five becomes root on the host, including from inside a container.
- NGINX open source has no long-term support release. Each branch gets fixes for about a year, and roughly three in four NGINX websites run a retired branch that got no fix this week.
- Distro backports end with the distro's own life cycle. As of November 2026, HeroDevs is the only vendor offering commercially supported, OS-independent drop-in replacements for end-of-life NGINX open source releases: RPM, deb, and container builds of 1.27.1, 1.28.x, and 1.31, with ongoing security patches.
What is nginx2root?
nginx2root is five independent remote code execution bugs in NGINX, plus a Linux kernel flaw that turns any one of them into root on the host.
Xint researchers found all five, four of them with a fully automated scan. Nir Ohfeld and Tomer Schwartz at Wiz Research found the two HTTP/2 bugs independently, and so did Rapid7, Metnir, and Ikotas Labs.
Each one is a separate attack path, with its own configuration requirements:
All five run through 1.31.8. The first-affected versions are F5's ranges, as summarized by Wiz. Xint's tested paths for the last two start a little later.
This is not a one-off. The nginx.org advisory list recorded 2 vulnerabilities in all of 2025. As of November 17, 2026, it had recorded 26 in 2026, before nginx2root.
How does CVE-2026-123007 work?
CVE-2026-123007 is a bookkeeping bug in HTTP/2 flow control that ends in an out-of-bounds memory copy. It needs nothing but HTTP/2: Wiz got code execution on a server serving plain static files.
HTTP/2 lets a client cap how much data the server sends, called the send window. NGINX tracks the connection-wide window in h2c->send_window, and the spec caps it at 2^31 - 1.
When NGINX queues response data, it subtracts the length from the window. If the stream is canceled before the data goes out, ngx_http_v2_filter_cleanup() gives the credit back.
The refund never checks the cap.
Xint's attack goes like this:
- Raise the window to its maximum, set the initial window for new streams to 0, and flood PING frames so the acknowledgments fill the TLS and TCP buffers. Response data now sits in NGINX's queue and cannot leave.
- Release that data into the queue. NGINX subtracts its length, call it Q.
- Send a WINDOW_UPDATE granting Q back, then RST_STREAM to cancel the streams. Cleanup refunds Q a second time.
The window is now the maximum plus Q, and the bounds check breaks. ngx_http_v2_state_window_update() computes the room left as the maximum minus the current window. The window is an unsigned size_t, so the subtraction wraps to a very very large positive number and NGINX accepts every WINDOW_UPDATE after that. The attacker can push the window to any 64-bit value.
ngx_http_v2_send_chain() then casts the window to the signed off_t. A value just under 2^64 becomes a small negative number, -d, and that becomes the DATA frame size. A buffer's end pointer now sits d bytes before its start. In the TLS send path, ngx_ssl_send_chain() hands the pointer difference to memcpy() as a length of 2^64 - d.
That should crash the worker.
It does not, because glibc's x86-64 memcpy() has copied backward from the end of the destination since glibc 2.24 in 2016. The destination plus the length wraps around to d bytes below the destination, so the copy loop runs once: 128 bytes from the start of the source, and 160 bytes from just below the wrapped end.
Xint lines those 160 bytes up with Cookie headers and a multi-range Range request. One copy overwrites the heap metadata in front of the TLS buffer and sends NGINX image and heap pointers back in the response. With the addresses in hand, the attacker overwrites a cleanup function pointer and runs commands as the NGINX worker.
Xint ran it against public IP addresses on AWS, GCP, and Azure. Wiz confirmed it, with an ASLR bypass, on the official 1.31.7 and 1.31.8 builds.
None of it shows up in the access log. WINDOW_UPDATE and RST_STREAM frames are not requests.
How does CVE-2026-123633 work?
CVE-2026-123633 leaves an HTTP/2 connection with a live request on NGINX's list of connections it is allowed to close. When NGINX runs short of connection slots, it closes that connection out from under its own request.
Each worker has a fixed number of slots, set by worker_connections, and client and upstream connections share them. When 1/16 or fewer are free, ngx_drain_connections() closes connections from a reusable queue. Idle keep-alive connections and HTTP/2 connections with no active streams go on that queue.
The bug is an ordering mistake in ngx_http_v2_handle_connection(): it puts the connection on the reusable queue first and checks for a half-read frame second. So the attacker:
- Sends the first part of a HEADERS frame. With no active streams, the connection goes on the reusable queue.
- Sends the rest. ngx_http_v2_create_stream() opens a stream, but never takes the connection off the queue.
- Lets the request proxy to a backend. Opening the upstream connection calls ngx_get_connection(), which runs the drain.
The drain picks the attacker's connection and tries to send a GOAWAY frame. The client has already reset the TCP connection, so the write fails, and NGINX closes the connection and destroys the request pool, upstream state included.
Then the drain returns and NGINX carries on with the upstream connect, using memory it just freed.
Xint's exploit grooms the heap so a glibc allocator header lands on the freed upstream structure and points its peer address at the attacker's own server. NGINX connects there and sends the freed request buffer, which is full of pointers. That is the ASLR bypass. The worker crashes, however, its replacement has the same memory layout. A second pass reclaims the freed request with a fake one whose upstream read handler is execv().
CVE-2026-123633 has been in NGINX since 1.19.7, close to six years. It needs a proxy configuration, which is common in most production environments using NGINX.
What about the other three nginx2root CVEs, and the kernel bug?
The other three are use-after-free bugs too, and turning off HTTP/2 blocks none of them.
CVE-2026-123634, the DNS resolver. When several lookups wait on the same hostname, the resolver walks a waiting list and saves the next entry before calling each handler. A mirror subrequest and its main request can wait on the same name. If the lookup fails and the client resets the connection, terminating the main request also frees the mirror's lookup context, and the loop steps into freed memory and calls a handler the attacker controls. It needs proxy_pass with a destination taken from the request, and NGINX's resolver has to be able to reach the attacker's DNS server.
CVE-2026-121810, HTTP/3. Same pattern as CVE-2026-123633, on QUIC. ngx_quic_create_stream() takes the parent connection off the reusable queue, but the new stream only joins the parent's stream tree after its slot is allocated. Closing an idle stream in that window can put the parent back on the queue. The request's upstream connect then drains the parent and frees its own request.
CVE-2026-113425, the mail proxy. During an auth_http login, the connection to the auth service still points at the client's session. If a reply to the client fails, ngx_mail_send() closes the client and frees the session, but leaves the auth connection open. The auth connection's next event uses the freed session. Xint got to system() without valid credentials.
The kernel bug. Every NGINX bug above runs code as the NGINX worker, which normally has very few privileges. So, Xint went looking for a way up and found a use-after-free in the Linux kernel's SCTP send path, present since Linux 4.15 in 2018. A worker that opens an SCTP socket can use it to get root on the host. It worked from inside a Docker container too, and every container on that host shares the kernel. On many distros the SCTP module loads automatically the first time a program asks for it. As of Xint's post, there was no kernel fix.
How does the NGINX support life cycle work?
NGINX open source has no long-term support release. A branch gets fixes for about a year, and only the newest release on that branch gets them.
The project runs two branches at a time. Mainline, with an odd minor number, gets new features and fixes. Stable, with an even minor number, gets critical fixes only.
Every April, the current mainline is forked into the next stable branch and the previous stable branch is retired. A few weeks later the next mainline opens, and the previous mainline stops getting fixes too.
Inside a branch, each release replaces the last. When nginx.org fixes a CVE, the fix ships in the newest stable and mainline releases. It is not backported to earlier releases on the same branch, and it does not go to retired branches at all.
Release dates are from nginx.org news and versionlog. Future dates are estimates based on the pattern, and endoflife.date tracks the same schedule. Our NGINX version and end-of-life reference has the dates for every branch.
So a server that was fully patched last spring is end of life this spring, and nobody touched it.
NGINX Plus runs on F5's own R-numbered schedule. F5 lists the fixed NGINX Plus releases in advisory K000164058.
The short window matters more than it used to. With 26 advisories so far in 2026, every fix published since April 14 is a fix the 1.28 branch will never get. nginx2root adds five more.
Which end-of-life NGINX versions are affected by nginx2root?
Every retired branch you are likely to find in production is in range for at least three of the five, and none of them gets a fix from nginx.org.
CVE-2026-123007 covers every release since HTTP/2 arrived in 1.9.5. The resolver and mail proxy bugs go back further. Only HTTP/3 and the HTTP/2 use-after-free are newer.
Linux distros are the one real nuance. Per Xint, Ubuntu 24.04 ships 1.24.0, Ubuntu 22.04 ships 1.18.0, and Debian 12 ships 1.22.1. Distros backport security fixes into their own packages without changing what nginx -v prints. If you run the distro's package on a supported release, your fix comes from the distro's advisory, on the distro's schedule.
Past a distro's own life cycle, the options get thinner. A handful of vendors sell backported nginx packages for end-of-life Linux distros, and a couple of Kubernetes vendors maintain ingress-nginx forks with their own 1.27.1 backports. Everything else depends on whoever built it: (1) NGINX from nginx.org's packages left on a retired branch, (2) official container images pinned to an old tag, (3) source builds, and (4) products that compile NGINX in, like the community Ingress NGINX controller, which built 1.27.1.
How many systems run NGINX, and how many are end of life?
NGINX runs more than 225 million websites, and at least 74% of NGINX websites report a branch that nginx.org no longer patches.
The three counts below measure different things:
- Websites: Netcraft's September 2026 survey puts NGINX on more than 225 million sites.
- Share of the web: W3Techs has NGINX on 29.7% of websites whose web server it can identify, as of November 19, 2026.
- Internet-facing hosts: Xint counted 56.7 million hosts on Shodan on November 10, 2026. Of the 11.94 million that reported a version, 98.9% were in range for CVE-2026-123007.
W3Techs also breaks NGINX websites down by branch. Every branch above 1% on November 19, 2026:
Source: W3Techs. The two supported branches add up to 19.2%. The retired branches in the table add up to 74.3%, and the other 6.5% is spread across branches too small to list.
Two things in that table stand out. First, 1.29 holds 14.1% of NGINX websites six months after it stopped getting fixes. Second, 1.24 and 1.18 are the Ubuntu 24.04 and 22.04 defaults, so some of that share gets distro backports and some of it does not, and a version string cannot tell you which.
These are version strings, not vulnerability scans: many servers hide their version, and some report an old version with backported fixes. The direction is still clear. Most NGINX on the internet runs a branch F5 did not fix this week.
What can I do about nginx2root right now?
Patch if you can. If you cannot, turn off what each bug needs, and know which bugs that leaves open:
- Upgrade to 1.30.7 or 1.31.9, or to a distro package that carries the fixes. Then restart, because a reload does not replace the running binary.
- Turn off HTTP/2 to block CVE-2026-123007 and CVE-2026-123633. It does nothing for the other three, and it breaks anything that needs HTTP/2, like native gRPC.
- Turn off HTTP/3, point proxy_pass at fixed upstream groups instead of request-time DNS, and keep the mail proxy off untrusted networks.
- Block the SCTP module on hosts that do not use it, to break the chain to root.
- Look for programs started by NGINX worker processes, and for worker crashes. The first is the clearest sign of a successful attack.
Xint's post has the full commands for each of these. All of them are stopgaps.
Where does NES for NGINX fit?
F5's answer for a retired branch is to upgrade to 1.30 or 1.31. Where that will not happen this year, the alternative is someone else's patches: your distro, an extended-support vendor, or NES (Never-Ending Support) for NGINX.
As of November 2026, HeroDevs is the only vendor offering commercially supported, OS-independent drop-in replacement versions of end-of-life NGINX open source releases, with ongoing security patches.
NES for NGINX is a drop-in replacement for nginx.org's packages, with HeroDevs security fixes. Same paths, same configure arguments, same nginx user, systemd unit, and dynamic modules, so existing configs just keep working. It covers three NGINX branches: 1.27.1 and 1.28.x, which upstream retired in June 2025 and April 2026, and 1.31. It ships as:
- Signed RPMs for RHEL 8, 9, and 10, and for Oracle Linux, Rocky Linux, and AlmaLinux 8 and 9, on x86_64 and aarch64
- deb packages for Debian 12 and Ubuntu 22.04 and 24.04, on x86_64 and aarch64
- OCI images on Alpine 3.24 and Debian 12 bases, for linux/amd64 and linux/arm64
The current release, v1.31.9-nes-1.31.3, is built on NGINX 1.31.9, so it has the fixes for all five nginx2root CVEs. The release notes have the details.
NES builds keep getting fixes after upstream retires a branch. When 1.33.0 opens next year and nginx.org stops fixing 1.31, NES for NGINX will keep patching 1.31. The upgrade happens on your schedule, not on F5's April calendar.
Every release ships with:
- Release notes that mark each CVE reachable, not reachable, off by default, or not affected, with what fixed it
- OpenVEX statements, so scanners close findings that do not apply
- An SBOM and signed packages
- No license file, no usage reporting, and support for air-gapped installs
We have already done this on a retired branch. NES for Ingress NGINX has patched NGINX 1.27.1 since April 2026, a branch upstream retired in June 2025, and it shipped fixes for the four nginx2root CVEs that affect the controller within a day of disclosure.
Most teams should upgrade where they can. NES is for where they cannot: a fleet pinned to a branch by an appliance, a vendor platform, a compliance freeze, or a migration that will take longer than one April.
Frequently asked questions
Am I safe if I do not use HTTP/2?
Not necessarily. HTTP/2 only matters for CVE-2026-123007 and CVE-2026-123633. The resolver, HTTP/3, and mail proxy bugs each need a different configuration, and turning off HTTP/2 blocks none of them.
Does nginx -v tell me whether I am patched?
Only for nginx.org builds. Distro packages backport fixes without changing the version string, so check the full package version against your distro's advisory.
Is Ingress NGINX affected?
Yes. The community controller compiles NGINX 1.27.1 and was retired in March 2026, so it will not get a fix. NES for Ingress NGINX fixes the four nginx2root CVEs that affect it.
Does patching NGINX fix the kernel bug?
No. The SCTP flaw is in the Linux kernel. Patching NGINX closes the way in, but the kernel needs its own fix. Until one ships, block the SCTP module on hosts that do not use it.
When does my branch stop getting fixes?
Stable branches retire every April, and mainline branches a few weeks later. Our NGINX version and end-of-life reference has the dates for every branch.
Is NGINX 1.18.0 or 1.24.0 affected by nginx2root?
Yes. NGINX 1.24.0 is in range for four of the five, and 1.18.0 for three: CVE-2026-123007, CVE-2026-123634, and CVE-2026-113425. nginx.org will not fix either. Ubuntu 24.04 and 22.04 package these versions, so if you run the distro's package on a supported release, your fix comes from the distro's advisory.
Security fixes for NGINX after end of life
If your NGINX fleet is on a retired branch and the upgrade is not happening this quarter, NES for NGINX keeps it patched while you plan the move. Talk to our team about coverage.
Resources
View All Articles


.png)