who we are

security expertise, democratized

A close-knit team of experienced security professionals with a shared conviction: real security expertise should be accessible to every organization, not just those with enterprise budgets.

NGINX2Root: Five Critical NGINX Flaws Open a Path From Web Request to Root
← back to insights
InsomniSec Team · November 19, 2026

Five critical flaws in NGINX, the software behind a large share of the world's websites, load balancers, and API gateways, could let an attacker on the internet take control of a company's web server without logging in. The researchers who found them, at security firm Xint, went a step further: by pairing the worst flaw with a separate, still-unfixed Linux bug, they gained full administrator ("root") control of the machine underneath, and in testing they broke out of a container to take over the host it was running on. Fixes were released on November 18.

No attacks have been reported yet, but two security firms have already published attack code for the most serious flaw, and most exposed servers have not been updated. On the morning of November 19, internet scanning firm Censys counted roughly 8.8 million exposed NGINX servers against only about 425,000 that had been patched. Treat this as an emergency patch. Update internet-facing NGINX first, and where that cannot happen today, switch off HTTP/2 until it can. The Linux half of the chain has no fix yet, which makes patching NGINX the step that matters most.

The headline flaw is CVE-2026-123007, a bug in NGINX's HTTP/2 flow control that is present in every official release from 1.9.5 (September 2015) through 1.31.8. F5, which maintains NGINX, scores all five NGINX2Root flaws 9.2 (Critical) under CVSS 4.0 and 8.1 under CVSS 3.1. They are fixed in NGINX Open Source 1.31.9 (mainline) and 1.30.7 (stable), and in NGINX Plus 37.3.0.1 and 37.0.8.1.


Who is affected

Each of the five flaws lives in a different NGINX feature, and each needs that feature switched on. The one that matters to almost everyone is CVE-2026-123007, because it needs nothing more than HTTP/2 enabled on a listening port. Detection researcher Florian Roth estimates that about two thirds of HTTPS NGINX servers have HTTP/2 switched on.

CVE Component Exposed when First affected release Does disabling HTTP/2 block it?
CVE-2026-123007 HTTP/2 flow control HTTP/2 enabled on any listener 1.9.5 Yes
CVE-2026-123633 HTTP/2 upstream handling HTTP/2 enabled, NGINX passing requests to a backend, and the worker running low on worker_connections 1.19.7 Yes
CVE-2026-121810 HTTP/3 (QUIC) HTTP/3 enabled and NGINX proxying to upstreams 1.25.0 No
CVE-2026-123634 Resolver Proxied server name built from variables, a resolver, and an SSI or mirror subrequest that resolves the same name 1.13.4 No
CVE-2026-113425 Mail proxy Mail proxy with auth_http, reachable by the attacker 0.5.15 No

Products affected: NGINX Open Source, NGINX Plus, the F5 NGINX Ingress Controller for Kubernetes, NGINX Gateway Fabric, and NGINX Instance Manager. F5 has shipped updates for some of these and says it is still working on the rest. Container images built on the official NGINX images are affected until rebuilt. Products that embed NGINX need their own vendor fixes; researchers at Metnir, one of the teams that reported the HTTP/2 flaws, say Kong, Apache APISIX, and OpenResty can also be crashed through them.

Not affected by NGINX2Root, according to F5: BIG-IP (all modules), BIG-IQ, F5OS, BIG-IP CNF, BIG-IP Next for Kubernetes, and F5 AI Gateway. F5 Distributed Cloud and NGINX One Console were still under review at the time of writing. Note that F5's same out-of-band release (K000164058) also fixes 12 separate BIG-IP vulnerabilities, some of them critical, so BIG-IP owners have their own patching to do this week.

Scale: Xint counted 56.7 million NGINX hosts on Shodan on November 10. Of the 11.94 million that reported a version number, 98.9% were in the affected range. Censys's tracking, cited above, puts the number of exposed and still-unpatched servers at about 8.8 million.

A note on cloud and CDN providers: Xint coordinated the fix with AWS, Microsoft Azure, and Google Cloud before going public, and Cloudflare says its edge is patched and that origins it proxies are shielded while customers update. That protects the providers' own services; it does not patch NGINX that you run yourself on cloud virtual machines, in containers, or in Kubernetes.


Two names, many discoverers

Several teams found these flaws independently, so the coverage uses two different names:

  • NGINX2Root is Xint's name for all five NGINX CVEs plus the Linux kernel chain.
  • NGINX2Shell is what Ikotas Labs called CVE-2026-123007 when it announced the same flaw on November 18.

Four more teams found and reported the two HTTP/2 flaws, CVE-2026-123007 and CVE-2026-123633, without giving them a name: Wiz, Rapid7 (where Stephen Fewer found CVE-2026-123007), Palo Alto Networks, and Metnir.

If your vendors, scanners, or news feeds use either name, or simply cite one of these researchers, they mean the same underlying issues. The CVE numbers are what to track.


How the flaws work

HTTP/2 lets a browser send many requests at once over a single connection. To stop either side from being flooded, it uses flow control: each side advertises a "window" of how much data it is willing to receive, and the other side tracks how much credit it has left.

CVE-2026-123007 breaks that bookkeeping. When an attacker cancels a stream that still has response data queued, NGINX returns the unused credit to the connection's window without checking an upper limit, and a later unsigned comparison fails to catch the result. Rapid7 describes it as an integer underflow: NGINX miscalculates how much it is allowed to send, then uses an invalid length when copying a later response. The result is an out-of-bounds write on the heap, which Xint turned into code execution by leaking NGINX's memory addresses and hijacking a cleanup function pointer.

The attack runs with the privileges of the NGINX worker process and needs no account. Xint validated it over ordinary public HTTPS on AWS, Google Cloud, and Azure under normal traffic. Wiz reached code execution against official NGINX 1.31.7 and 1.31.8 builds serving nothing but static files over HTTPS, with no backend application and no third-party modules.

The other four are use-after-free bugs, where NGINX keeps using memory after it has been released:

  • CVE-2026-123633 (HTTP/2): an HTTP/2 connection with an incomplete frame stays in a queue of connections that can be reclaimed. If NGINX runs short of connection slots and reclaims it while an upstream connection is being set up, it frees a request that is still in use.
  • CVE-2026-121810 (HTTP/3): a similar pattern, where the parent QUIC connection is wrongly marked as reclaimable while an HTTP/3 stream is being created.
  • CVE-2026-123634 (resolver): when the main request ends, NGINX frees the DNS lookup context of a subrequest (from mirror or SSI) while the resolver still holds a pointer to it. The attacker needs a DNS server that NGINX's resolver will query.
  • CVE-2026-113425 (mail proxy): the client session is freed while the auth_http connection still points to it.

Xint says each of the five leads to remote code execution on its own. F5's advisories state that code execution requires address space layout randomisation (ASLR) to be disabled or bypassed. That is less reassuring than it sounds: Xint and Wiz both report bypassing it, and Wiz says the two HTTP/2 flaws can be used to defeat ASLR on their own. Luxembourg's national CERT, CIRCL, has specifically warned organisations not to close scanner findings on the grounds that ASLR is enabled.


From web server to root

Code execution as the NGINX worker is serious on its own: it exposes TLS keys, traffic, and configuration secrets, and gives an attacker a foothold on the network. Xint showed that it does not have to stop there.

The second stage uses a use-after-free in the Linux kernel's SCTP networking code, present since Linux 4.15, in which an association can be moved to another socket while a send is still waiting, and the waiting operation then frees it. Xint used it to leak kernel memory, defeat kernel address randomisation, and call arbitrary kernel functions, giving full root on the host. In testing, the same chain escaped a Docker container running NGINX and took root on the host machine itself. On a shared container host, that means one compromised NGINX container can put every other container on the machine at risk.

Two points matter for defenders:

  • The kernel bug still has no fix and no CVE as of November 19. Xint has withheld its details. SCTP is a niche protocol that most web servers never use, but Xint notes that many distributions load the module automatically on demand.
  • Patching NGINX breaks the chain. The kernel bug needs local code execution first; without an NGINX flaw, a remote attacker has no way in.

Severity

Source CVE-2026-123007 Other four CVEs
F5 (CVSS 4.0) 9.2 Critical 9.2 Critical
F5 (CVSS 3.1) 8.1 8.1
nginx.org label Major Major for the mail proxy flaw (CVE-2026-113425); Medium for the rest
Red Hat Critical, 8.1 Not stated in reporting
Ubuntu High Not stated in reporting

Rapid7 gives CVE-2026-123007 a vector of AV:N/AC:H/AT:P/PR:N/UI:N: network-based, no privileges, no user interaction, but with high attack complexity. That complexity is real (see below), but it describes the effort needed today, not a ceiling. The gap between nginx.org's "Medium" labels and F5's 9.2 scores is worth noting; scanners and patch dashboards that rely on the project's own labels may rank the HTTP/2, HTTP/3, and resolver flaws lower than they deserve. NVD had not yet analysed the CVEs and no EPSS score had been published at the time of writing, so tools that depend on either may show little or nothing.


Exploitation status

As of the afternoon of November 19, no exploitation in the wild has been reported, CERT-EU and F5 say the same, and none of the five CVEs is in CISA's Known Exploited Vulnerabilities catalogue.

  • Two public exploits now exist. Rapid7 published a crash trigger and a full remote code execution chain for CVE-2026-123007 on GitHub, targeting the official linux/amd64 Docker image of NGINX 1.31.8 with HTTP/2 and TLS. Censys has since published its own proof of concept.
  • Rapid7's version has practical limits. It needs roughly 128 GB of HTTP/2 traffic over a single connection, which Rapid7 says takes anywhere from about two minutes to an hour depending on bandwidth; on links slower than about 300 Mbit/s, NGINX's default one-hour connection limit cuts it off. It relies on a memory-copy routine that glibc selects on x86-64 processors with AVX-512 support, its own notes say it suits only a freshly started Docker container on the same machine, and Rapid7 says it probably fails when HTTP/2 is proxied through a front end. watchTowr adds that exploitation is difficult and tends to crash workers along the way.
  • Those limits are already eroding. Censys says it reproduced the flaw's behaviour in its lab over cleartext HTTP/2 (without TLS) and without the large traffic volume Rapid7's exploit needs. Censys has not said whether its reproduction reached code execution or only corrupted memory, but the 128 GB requirement should no longer be treated as a safety margin. Cleartext HTTP/2 is most often used inside networks, between load balancers, service meshes, and backends, so internal NGINX instances deserve the same attention as internet-facing ones.
  • Stronger exploits exist privately. Xint and Wiz both report exploits that work in realistic conditions and are withholding them. Rapid7 notes that other routes to exploitation may exist beyond its own.
  • The fix has been readable for a week. The HTTP/2 changes were visible in NGINX's public GitHub repository from November 11, a week before disclosure. Skilled attackers can work backwards from a fix, so the absence of reported attacks should not be read as the absence of attackers.
  • Fake exploits are circulating. Precursor Security has warned of copycat "NGINX2Root" repositories on GitHub. Do not run any of them outside an isolated lab; fake exploit repositories are a common way to infect researchers and administrators.

The useful comparison is NGINX Rift (CVE-2026-42945), disclosed by F5 in May. Attackers were exploiting it within days. With a working public chain for CVE-2026-123007 already available, we would not plan around a longer window this time.

We have not tested any of the public code.


What you should do

1. Find out where you are exposed

Version and configuration both matter, so check both.

  • Version and build: run nginx -v, and confirm the HTTP/2 module is built in with nginx -V 2>&1 | grep -q -- '--with-http_v2_module' && echo "HTTP/2 module present".
  • HTTP/2 enabled: nginx -T 2>/dev/null | grep -nE 'listen .*http2|http2 on'
  • HTTP/3 enabled: nginx -T 2>/dev/null | grep -nE 'quic|http3'
  • Resolver, mirror, and SSI: nginx -T 2>/dev/null | grep -nE 'resolver|mirror|ssi on|proxy_pass .*\$'
  • Mail proxy: nginx -T 2>/dev/null | grep -nE '^\s*mail\s*\{|auth_http'
  • From the outside: openssl s_client -connect host:443 -alpn h2 </dev/null 2>/dev/null | grep 'ALPN protocol' shows ALPN protocol: h2 if HTTP/2 is accepted. Behind a CDN, test the NGINX origin directly; testing the public hostname only tells you about the CDN.
  • Do not trust the version string alone. Linux distributions backport fixes without changing the reported version (Ubuntu 22.04, for example, reports 1.18.0). Check the full package version against your vendor's advisory.
  • Look beyond the obvious web servers. NGINX sits inside reverse proxies, Kubernetes ingress controllers, API gateways, container images, and appliances, and these are easy to miss in an inventory.

2. Patch, then restart

Product Fixed version
NGINX Open Source mainline 1.31.9
NGINX Open Source stable 1.30.7 (also the upgrade path for older branches such as 1.28)
NGINX Plus 37.3.0.1 or 37.0.8.1 (37.2.0.1 and 37.0.7.1 fix CVE-2026-123633 only). R34 to R36 have no fix; move to a fixed 37.x build
F5 NGINX Ingress Controller 5.8.0, released November 18, which bundles NGINX 1.31.9 and NGINX Plus R37.3.0.1 (the 2026-lts-r11 release is not fixed)
NGINX Gateway Fabric 2.9.0, built on NGINX 1.31.9
Community ingress-nginx (Kubernetes) Retired project; no fix coming. Migrate, or disable HTTP/2 at the ingress
Official Docker images 1.31.9 and 1.30.7 tags published, including Alpine variants; nginx:latest, mainline, stable, and alpine now point to fixed builds

Distribution status, as of the afternoon of November 19:

Platform Status
Ubuntu Fixed (USN-9159-1) for 22.04, 24.04, 26.04, and 26.10; older releases through Ubuntu Pro (ESM)
Debian Fixed in trixie (Debian 13) by DSA-6642-1, package 1.26.3-3+deb13u11, and in unstable (sid) 1.30.6-4; bookworm (Debian 12) and forky still vulnerable, no fix listed
Red Hat Rated Critical (CVSS 3.1 8.1, preliminary); no RHEL errata or per-product fix status published yet. Red Hat points to security bulletin RHSB-2026-019 for mitigation steps
AlmaLinux Fixed for AlmaLinux 8, 9, and 10
Amazon Linux Fixed on all supported releases: Amazon Linux 2 nginx1 Extra (ALAS2NGINX1-2026-018), Amazon Linux 2023 (ALAS2023-2026-3494, NGINX 1.30.7), and the Amazon Linux 2027 Preview (nginx ALAS2027-2026-386 and nginx-awslc ALAS2027-2026-385)
Alpine Fixed
SUSE Rated Important; no SUSE-SU advisory yet. Fixed in openSUSE Tumbleweed (NGINX 1.31.9). Fixes are in QA, not yet released, for SLES 15 SP7, SP6-LTSS, SP5-LTSS, and SP4-LTSS, and in progress for SLES 16.0 and 16.1. Other SLES 15 service packs and openSUSE Leap 15.x and 16.x are listed as affected with no fix scheduled

The same releases also fix five lower-severity NGINX issues, including a certificate verification bypass and an infinite-loop denial of service, so upgrading is worth doing even where none of the NGINX2Root conditions apply.

After upgrading, fully restart NGINX (or complete a supported live binary upgrade). A reload leaves the old executable running. For containers, rebuild and redeploy the image; restarting a container reuses the old, vulnerable image.

If your platform has no fix yet, apply the workarounds below and keep checking.

3. If you cannot patch today, switch off the vulnerable features

  • Disable HTTP/2 on affected listeners. On NGINX 1.25.1 and later, set http2 off; in each affected server block and remove http2 from listen lines. On 1.9.5 to 1.25.0, change listen 443 ssl http2; to listen 443 ssl;. This blocks CVE-2026-123007 and CVE-2026-123633 but not the other three. Browsers fall back to HTTP/1.1 automatically, but native gRPC will stop working, so test first where an application depends on it. Afterwards, confirm with the openssl check above that h2 is no longer offered.
  • Disable HTTP/3: remove quic listeners, set http3 off;, and send Alt-Svc 'clear' so clients stop trying it. Optionally block UDP 443 at the firewall.
  • Remove request-time DNS lookups: replace variable proxy_pass targets with fixed upstream groups, and avoid mirror and SSI where they are not needed. Setting mirror_request_body on reportedly stopped Xint's exploit, but it does not fix the bug.
  • Restrict the mail proxy: bind IMAP, POP3, and SMTP listeners to loopback, or limit them to trusted networks with a firewall.
  • Filter outbound traffic from NGINX. CVE-2026-123633 and CVE-2026-121810 need NGINX to open a connection to an attacker-controlled server; outbound filtering that limits NGINX to known backends closes that route.
  • Restart, do not just reload. A reload leaves old worker processes serving existing connections, and those workers keep the old configuration.

These steps reduce exposure; they do not replace the patch.

4. Close the path to root

Even after patching, remove the second stage of the chain where you can. On servers that do not use SCTP (almost all web servers), stop the module from loading:

echo "install sctp /bin/false" | sudo tee /etc/modprobe.d/disable-sctp.conf

This prevents the module from being auto-loaded in future. It does not unload a module that is already loaded (check with lsmod | grep sctp), and it does not help on kernels with SCTP built in. Watch for a kernel fix from your distribution.

5. Do not count on your WAF

A web application firewall does not replace patching here. CVE-2026-123007 is triggered by valid, low-level HTTP/2 control frames, such as WINDOW_UPDATE and RST_STREAM, which URL and body inspection never sees and signatures cannot easily tell apart from normal traffic. A CDN or WAF that terminates HTTP/2 and speaks HTTP/1.1 to NGINX may reduce exposure, and both Wiz and Rapid7 say proxied HTTP/2 makes current exploitation harder. If your front end passes HTTP/2 through to NGINX, or if the origin can be reached directly, NGINX is still exposed.

6. Watch for signs of trouble

CVE-2026-123007 leaves little trace in access logs, because HTTP/2 control frames are not logged as requests. A clean access log does not rule out an attack. CIRCL's response guidance (TR-105) and Xint both point to the same signals; none is conclusive on its own:

  • Long, lopsided connections. ss -tinp state established '( sport = :443 )' can reveal a long-lived connection from one IP where bytes_received keeps climbing while bytes_sent stays small and few requests are logged, often alongside many short TLS connections from the same address. The public exploit's 128 GB requirement makes this pattern hard to hide.
  • Request size versus bytes received. Add $connection, $connection_requests, and $request_length to a custom log_format and compare logged request sizes with the bytes the connection actually received.
  • Worker crashes and crash loops. Search the error log for worker process exited, signal 11, or segfault, and check coredumpctl list nginx. Failed exploitation attempts are likely to crash workers.
  • Processes started by NGINX. An auditd rule on execve and execveat filtered by the NGINX worker's user ID will record any program a worker starts. A web server worker should almost never launch a shell, curl, or wget. These records only exist from the moment the rule is installed, so add it now.
  • Unusual outbound connections or DNS lookups from NGINX hosts, including resolver errors or alerts where NGINX normally resolves nothing.
  • Unexpected SCTP activity. A web server that suddenly has the sctp module loaded, or SCTP sockets open, warrants investigation.

If you find signs of compromise, isolate the host, preserve memory and logs before rebuilding, and rotate everything the server could reach: TLS private keys, API keys and credentials in the configuration, and secrets available to the container or host.


A note on the pattern

NGINX has published 26 security advisories so far this year, according to Precursor Security's count, against two in all of 2025. NGINX Rift (CVE-2026-42945) was exploited within days of disclosure in May; critical HTTP/3 and HTTP/2 proxy flaws followed; and five more were fixed in 1.30.6 and 1.31.7 on October 14. NGINX2Root is the most serious yet, because the main flaw needs nothing beyond HTTP/2, a setting that is on for most HTTPS NGINX servers.

How it was found is part of the story. Xint says one of its researchers found CVE-2026-123007, and its fully automated scanner found the other four. Within about a month, Wiz, Rapid7, Ikotas Labs, Palo Alto Networks, and Metnir found the same HTTP/2 flaws independently. When six separate teams converge on a bug that sat unnoticed for more than a decade, it is reasonable to assume that well-resourced attackers can find bugs like it too.

Disclosure is changing in response. Xint's CEO said the team limited who it shared details with until the patch was public, because it judged NGINX2Root more exploitable and broader in impact than PHP2Shell, which we covered in October. Even so, the fix was readable in public code a week early, a working exploit appeared minutes after the announcement, and a second followed within a day. The SANS Internet Storm Center's advice is to treat this as the new normal rather than a one-off emergency, and we agree: the window between disclosure and a usable attack is now measured in hours, and patch processes that assume weeks will fall behind.

For most organisations, the practical lesson is the one Apache's HTTP/2 flaw taught last week: know where your web servers are, know which protocols they have enabled, and be able to patch or switch a feature off the same day. SANS's Johannes Ullrich warns that large organisations may not reach every NGINX instance before exploits mature, and recommends automating patching, reducing the number of internet-facing systems, and limiting what each application can reach. NGINX is often embedded where it is easy to forget, in ingress controllers, API gateways, appliances, and base images, so the inventory is the hard part.


Summary

Name NGINX2Root (Xint); CVE-2026-123007 also called NGINX2Shell (Ikotas Labs)
CVEs CVE-2026-123007, CVE-2026-123633, CVE-2026-121810, CVE-2026-123634, CVE-2026-113425
Type HTTP/2 flow-control integer underflow leading to a heap overflow; four use-after-free bugs; each can give remote code execution as the NGINX worker
Chain to root Unpatched Linux kernel SCTP use-after-free (Linux 4.15 and later, no CVE yet); container escape demonstrated
Severity F5: 9.2 (CVSS 4.0), 8.1 (CVSS 3.1) for all five; Red Hat: Critical; Ubuntu: High
Affected CVE-2026-123007: every official NGINX release 1.9.5 to 1.31.8 with HTTP/2 enabled; NGINX Plus before 37.0.8.1 and 37.3.0.1; NGINX Ingress Controller before 5.8.0; NGINX Gateway Fabric before 2.9.0
Not affected BIG-IP, BIG-IQ, F5OS, BIG-IP CNF, BIG-IP Next for Kubernetes, F5 AI Gateway
Fixed NGINX 1.31.9 (mainline) and 1.30.7 (stable), November 18, 2026; NGINX Plus 37.3.0.1 and 37.0.8.1; Ingress Controller 5.8.0; Gateway Fabric 2.9.0; Ubuntu, Debian 13, AlmaLinux, Amazon Linux (2, 2023, and 2027 Preview), openSUSE Tumbleweed, and Alpine packages
Still waiting Debian 12 (bookworm), RHEL, SLES and openSUSE Leap; Linux kernel SCTP fix
Workaround Disable HTTP/2 and HTTP/3; remove variable proxy_pass, mirror, and SSI where possible; restrict the mail proxy; filter outbound traffic; restart, do not reload; block the SCTP module
Exploitation None reported in the wild; not in CISA KEV; public exploits for CVE-2026-123007 from Rapid7 (needs about 128 GB over one connection) and Censys (reproduced over cleartext HTTP/2 without the large traffic volume); Xint and Wiz exploits withheld; fake exploits circulating
Exposure About 8.8 million exposed and unpatched servers against about 425,000 patched (Censys, November 19)
Detection Long-lived connections with high inbound and low outbound bytes; worker crashes; NGINX workers starting processes; unusual outbound connections or DNS lookups; unexpected SCTP use

NGINX2Root combines the things that make a vulnerability urgent: software that runs almost everywhere, a trigger that needs only a common setting, no login, a public exploit, and a demonstrated path to full control of the host. The fix is out, several major Linux distributions now ship it, and switching off HTTP/2 is a workable stopgap where yours does not yet. Find your NGINX instances, including the ones hidden inside other products, and patch them today.

If you need help finding every NGINX instance in your environment, confirming that patches and vendor backports are actually in place, or monitoring for the connection patterns and process activity that would signal an attack, get in touch.

← all insights