NGINX2Root (CVE-2026-123007): nginx flaw, check your exposure

ThomasLe 20 novembre 2026

Introduction

On 18 November 2026, nginx released fixes for five vulnerabilities grouped under the name NGINX2Root and discovered, among others, by the company Xint. The most serious one, CVE-2026-123007, sits in the handling of HTTP/2: an attacker with no account can run commands remotely (RCE, remote code execution) on an nginx server, with the rights of the process that handles requests (the worker), as soon as HTTP/2 is enabled. It has been present since version 1.9.5, released in 2015.

nginx is everywhere: web server, reverse proxy, load balancer, Kubernetes ingress controller, and a building block embedded in appliances and software. As with PHP2Shell, an up-to-date application can therefore be exposed by the engine that serves it.

In this article, we explain the mechanism in plain words, then in detail for technical teams. We separate what is demonstrated from what is not, we give the state of the distributions as of 20 November, and we provide commands tested by us (we flag the ones that are not) to check your exposure.

Please note: the situation is evolving quickly. The information in this article reflects official advisories and the publications of the vendors and researchers consulted as of 20 November 2026. Sources are listed at the end of the article.


TLDR: the essentials in 30 seconds

  • What: five flaws in nginx. The main one, CVE-2026-123007, is an integer overflow in HTTP/2 flow control that leads to an out-of-bounds memory write. It allows unauthenticated remote code execution (RCE). A public exploit exists; it requires a very large volume of traffic.
  • Who: nginx 1.9.5 to 1.31.8 with HTTP/2 enabled (the other four flaws need more specific configurations), NGINX Plus, and anything that embeds nginx. Fixed in 1.31.9 and 1.30.7.
  • What to do: update, then restart nginx (a simple reload is not enough). Otherwise, disable HTTP/2. Check your distribution's package: some already fixed it, others have not.
  • Check for yourself: 1. version · 2. is HTTP/2 enabled? · 3. the other flaws · 4. distribution · 5. restart · 6. look for signs

At a glance

Key point Detail
CVE CVE-2026-123007 (main), CVE-2026-123633, CVE-2026-123634, CVE-2026-121810, CVE-2026-113425
Component HTTP/2 handling (two flaws), DNS resolver, HTTP/3, mail proxy
Cause (CVE-2026-123007) A flow-control counter goes past its limit and makes nginx perform a memory copy of a huge size
Severity nginx: "major" for CVE-2026-123007 and CVE-2026-113425, "medium" for the other three. F5: CVSS v4.0 9.2 and CVSS v3.1 8.1 for CVE-2026-123007
Demonstrated Code execution with the rights of the worker process, by three teams (Xint, Wiz, Rapid7); public exploit: Rapid7's (Xint and Wiz did not publish theirs)
Fixed in nginx 1.31.9 and 1.30.7; NGINX Plus 37.0.8.1 and 37.3.0.1
Workaround Disabling HTTP/2 blocks CVE-2026-123007 and CVE-2026-123633, not the other three
Exploitation Not reported as of 18 November (Cloudflare, Wiz); none of the five was in CISA's KEV catalog (known exploited vulnerabilities) on that date


What happens technically?

In plain words

With HTTP/2, several exchanges share a single connection. So as not to be overwhelmed, the client tells nginx how much data it agrees to receive: it is a counter, the "flow-control window". If the client cancels an exchange while nginx has already queued data for it, nginx gives that credit back to the counter, but without checking a maximum limit. By repeating the operation, the attacker makes the counter go past its limit. The safety check that was supposed to bound it then stops working, and nginx ends up copying an enormous amount of data.

The result: nginx reads and writes outside the memory reserved for it. The attacker can first read internal addresses (which defeats memory randomisation, ASLR), then overwrite a function pointer to run their commands.

For a decision maker, two points matter. No authentication is needed: it is enough that an encrypted (TLS) HTTP/2 port is reachable. And the HTTP/2 messages used for the attack do not appear in access logs: the absence of a trace is not proof that there was no attack.

Under the hood

  • Where: nginx's HTTP/2 flow-control code. When a stream is cancelled (RST_STREAM) while DATA frames are queued, ngx_http_v2_filter_cleanup() adds the deducted length back to the connection window, with no upper bound (Xint). The window then exceeds 2^31-1.
  • Why the protection fails: the check in ngx_http_v2_state_window_update() (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) falls back to unsigned arithmetic and accepts the following WINDOW_UPDATE frames. The window becomes a negative off_t, which is a copy length close to 2^64 in the TLS send path (ngx_ssl_send_chain). With glibc on x86-64, the end pointer "wraps around" and the copy only touches a short area (Xint).
  • HTTP/2 messages used: WINDOW_UPDATE (connection and stream), RST_STREAM, PING and SETTINGS (with SETTINGS_INITIAL_WINDOW_SIZE set to 0 to keep data queued). Xint describes the sequence but deliberately omits the final step (overwriting the pointer).
  • Vocabulary: Xint speaks of an overflow, Wiz of an underflow, Rapid7 of an integer underflow: it is the same defect, seen from two sides.
  • Upstream fix: commit b89c410, included in version 1.30.7 (Debian tracker). Ubuntu's fix is titled "Account for queued frames when…": it corrects the accounting of queued frames.

The other four flaws

CVE Exposure condition (according to Xint) Blocked by disabling HTTP/2?
CVE-2026-123633 HTTP/2 with an upstream server (reverse proxy); nginx must be able to connect to the attacker Yes
CVE-2026-123634 resolver, with a proxy_pass built from the request (for example $host) and the mirror directive; the attacker controls DNS answers No
CVE-2026-121810 HTTP/3 (QUIC) with an upstream server No
CVE-2026-113425 Mail proxy (IMAP, POP3, SMTP) with proxy on and auth_http No

These are use-after-free flaws (use of memory that has already been freed). nginx rates CVE-2026-113425 as "major" and the other three as "medium", but Xint says it developed a demonstration for each of them on the official 1.31.8 image. According to Wiz, the same releases fix ten CVEs in total; the other five, scored between 6.3 and 8.7, are denials of service or client-certificate bypasses.

A chain up to root

Xint also discovered a Linux kernel flaw, in the SCTP subsystem, present since version 4.15 (2018). Combined with any of the nginx flaws, it allowed Xint to obtain root rights on the host, including from a Docker container: a container shares its host's kernel. This flaw has no CVE number in the publication, and its details are withheld until a kernel fix is released. We could not check whether a fix has existed since 18 November.


What is demonstrated, and what is not

Claim Status
Out-of-bounds write in nginx memory Demonstrated (Xint, Wiz, Rapid7)
Code execution with the rights of the nginx worker Demonstrated by three teams, on nginx 1.31.7 and 1.31.8
Public exploit Yes, only one: Rapid7's (Docker image nginx 1.31.8 linux/amd64). Xint and Wiz kept theirs private
Code execution with no particular configuration other than HTTP/2 Demonstrated by Wiz on plain static files, with no application or third-party module
Getting root Announced by Xint (chain with the SCTP kernel flaw), details not published
Exploitation in the wild Not reported (Cloudflare, Wiz); none of the five CVEs in CISA's KEV catalog as of 18 November

What the public exploit actually requires. Rapid7 describes about 128 GB of HTTP/2 data over a single connection, roughly 2 minutes at 10 Gbit/s and 17 minutes at 1 Gbit/s. Since a connection lives for one hour by default in nginx, an attacker below about 300 Mbit/s cannot reach the end. The exploit also depends on a glibc x86-64 copy function chosen according to the processor's capabilities (AVX-512 instructions), and runs with the worker's rights. Rapid7 considers that an HTTP/2 connection relayed by a proxy probably does not carry the necessary messages.

What we do not know. Xint states that its exploit works with normal traffic in parallel and on different hardware, without giving a volume. F5 states that code execution requires ASLR to be disabled or bypassed: this condition was precisely bypassed in the demonstrations. In our view, the limits of Rapid7's exploit describe one exploit, not the flaw: they guarantee nothing for another processor or another system.

Our reading: the public exploit is costly (volume, duration, hardware), which leaves some time, but three teams have demonstrated code execution and the fix is available. We do not recommend waiting.


Who is affected?

  • Open source nginx from 1.9.5 to 1.31.8 for CVE-2026-123007, with HTTP/2 enabled. The other flaws have their own version ranges according to nginx.org (from 0.5.33 for the mail proxy, from 1.25.0 for HTTP/3), and require their own configuration. According to Xint, 98.9% of the 11.9 million nginx hosts that announce their version (Shodan, 10 November) fall within the vulnerable range: this figure says nothing about HTTP/2 or backported fixes.
  • NGINX Plus: affected, fixed in 37.0.8.1 and 37.3.0.1.
  • Official Docker images: nginx:1.31.8 is vulnerable, nginx:1.31.9 is fixed (we checked). Any image built on an older base remains exposed until it is rebuilt.
  • What embeds nginx: OpenResty and Kubernetes ingress controllers, according to Sophos, which specifies that they need their own updates. The ingress-nginx controller from the Kubernetes project was retired in March 2026: according to the project's statement, it no longer receives any security fix. It can therefore be exposed without ever being fixed: you must migrate.
  • Behind a CDN: according to Cloudflare, an origin reachable only through its HTTP proxy is protected during the update, because Cloudflare itself terminates HTTP/2 and HTTP/3. This covers neither TCP/UDP applications (Spectrum), nor DNS records without the proxy, nor the mail proxy. Cloudflare states that it has released no web application firewall rule for these flaws, because they are protocol and memory defects that a rule cannot reliably recognise.

Distributions: where do things stand?

Distributions often fix without changing the version number displayed by nginx -v. State observed on 20 November:

Distribution State
Ubuntu Fixed by notice USN-9159-1 of 19 November for supported releases (for example 1.24.0-2ubuntu7.20 for 24.04, 1.18.0-6ubuntu14.23 for 22.04). Older releases are reserved for Ubuntu Pro. We observed the fix in the Ubuntu 26.04 package
Debian Fixed in the security repositories for bookworm (1.22.1-9+deb12u11) and trixie (1.26.3-3+deb13u11), according to the security tracker
Alpine Alpine 3's nginx package is 1.30.7: fixed (observed)
Rocky Linux 9 (RHEL family) Package at 1.20.1: no mention of the CVE in its changelog (observed). Check with your vendor


Am I affected? A decision aid

Three questions, in order:

  1. Do I have an unpatched nginx? Upstream version below 1.30.7 or 1.31.9, or a distribution package without the fix. Think of base images, ingress controllers, appliances and software that embed nginx.
  2. Is HTTP/2 enabled, and on which ports? This is the condition for CVE-2026-123007. An nginx that only listens in HTTP/1.1 is not exposed to this flaw, but may be to the others.
  3. Can an attacker reach the port? Directly from the Internet, through a CDN that terminates HTTP/2, or from your internal network?

For nginx servers that are not yet patched, here is the order of handling we recommend:

Priority Situation
1 Handle first: nginx directly exposed to the Internet with HTTP/2 (reverse proxies, ingress controllers, web servers, appliances)
2 nginx exposed behind a CDN or proxy that terminates HTTP/2, or exposed with HTTP/3 or a mail proxy; nginx with HTTP/2 reachable from a wide internal network
3 Internal nginx without HTTP/2, development tools, test environments

This prioritisation is ours, not a vendor's: adapt it to your context.


Verification commands

The commands below are defensive: they read versions and configurations. Run them on your own systems. We tested them on nginx 1.31.8 (vulnerable) and 1.31.9 (fixed), as well as on Ubuntu, Rocky Linux and Alpine containers.

1. Which version is running?

nginx -v
nginx -V 2>&1 | tr ' ' '\n' | grep -E 'http_v2_module|http_v3_module|mail'

The first command gives the upstream version. The second lists the modules that are compiled in: a compiled module is not necessarily enabled (the configuration decides, see step 3), but the official images include HTTP/2, HTTP/3 and the mail proxy.

For running containers:

for c in $(docker ps -q); do
  v=$(docker exec $c nginx -v 2>&1 | grep -o 'nginx/[0-9.]*')
  [ -n "$v" ] && echo "$c $v"
done

For an image before deploying it:

docker run --rm --entrypoint nginx IMAGE -v

Compare with 1.30.7 and 1.31.9. According to the published advisories, only these two branches have a fixed upstream release: for older branches (1.28, 1.26…), you must move to 1.30.7 or rely on your distribution's backported fix. For a distribution nginx, go to step 4. Remember the base images in your registries and CI/CD pipelines: an image rebuilt on an unpatched base remains vulnerable.

2. Is HTTP/2 enabled?

In the loaded configuration (includes included):

sudo nginx -T 2>/dev/null | grep -nE 'listen[^;]*http2|http2[[:space:]]+on'

A result means HTTP/2 is enabled on at least one server. No result means it is not. The command recognises both spellings: http2 on; and the old form listen 443 ssl http2; (which nginx now flags as deprecated).

To see what a client sees from the outside:

curl -sk --http2 -o /dev/null -w '%{http_version}\n' https://your-service.example/

A result of 2 means HTTP/2 is negotiated, 1.1 that it is not. The OpenSSL alternative displays the negotiated protocol:

openssl s_client -alpn h2 -connect your-service.example:443 </dev/null 2>/dev/null | grep -i 'ALPN protocol'

Both tests measure the exposure of the surface, not the vulnerability: a fixed nginx also answers in HTTP/2. Behind a CDN, they query the CDN, not your nginx. Reserve them for systems you own.

3. The other four flaws

The other four flaws depend on specific directives:

sudo nginx -T 2>/dev/null | grep -nE 'listen[^;]*quic|http3[[:space:]]+on|[[:space:]]mirror[[:space:]]|resolver[[:space:]]|^[[:space:]]*mail[[:space:]]*\{'

Look for the lines that match the conditions in the table above: HTTP/3 (quic, http3 on), resolver combined with a proxy_pass built from the request, mirror, or a mail block. No result: these configurations are not present.

4. Is the distribution package fixed?

As for PHP2Shell, check the package changelog: the fix may be backported without changing the version.

# Debian / Ubuntu
dpkg -l | grep -E '^ii\s+nginx'
zgrep CVE-2026-123007 /usr/share/doc/nginx*/changelog.Debian.gz

# RHEL, Fedora, Rocky, Alma
rpm -qa | grep -i '^nginx'
rpm -q --changelog nginx | grep CVE-2026-123007

# Alpine
apk list -I | grep -i '^nginx'

On Debian and Ubuntu, a line citing the CVE means the fix is present. On the RHEL family, no result means the changelog does not mention the CVE: the package is probably not fixed, as we observed on Rocky Linux 9. On Alpine, compare the version with 1.30.7.

5. Is the fix actually loaded?

An update replaces the program on disk, but an nginx that is already running keeps the old version in memory. Reloading the configuration (nginx -s reload) does not change the program: only a restart does (Xint, Wiz, Cloudflare). To spot processes still running with a replaced executable:

sudo grep -lE 'nginx.*\(deleted\)' /proc/[0-9]*/maps 2>/dev/null

The identifiers displayed belong to processes to restart. No result: no process is running with a deleted executable.

6. Looking for signs

Few traces are expected: Xint specifies that HTTP/2 control messages are not logged as requests and that they are encrypted. Wiz speaks of general warning signs, not confirmed indicators of compromise. The most reliable signal is an nginx worker that launches a shell or a system command:

# Processes launched BY an nginx process (to be examined)
ps -eo pid=,ppid=,user=,comm=,args= | awk '
  { comm[$1]=$4; line[$1]=$0; ppid[$1]=$2 }
  END { for (p in ppid)
          if (comm[ppid[p]] ~ /^nginx/ && comm[p] !~ /^nginx/) print line[p] }'

Weaker signals, to cross-check:

# Worker crashes (the log path varies with your installation)
grep -E 'worker process [0-9]+ exited on signal' /var/log/nginx/error.log

# Long HTTPS connections whose received data grows very fast
ss -tinp state established '( sport = :443 )'

In the ss output, look for an old connection, from a single address, whose bytes_received grows very fast for very little bytes_sent, combined with many short TLS connections from the same address (Xint). We validated this command's syntax, not its interpretation under attack.

To have more context in your access logs, Xint suggests a format that adds the connection identifier, the number of requests on the connection and the request size. We validated that nginx accepts this configuration:

log_format h2_hunt '$remote_addr $connection $connection_requests $request_length "$request"';
access_log /var/log/nginx/access_h2.log h2_hunt;

If a worker has launched an unexpected program, consider the host compromised: isolate it, keep the logs and core dumps, and renew the secrets present on the machine (certificates, keys, tokens).


What to do?

1. Update, then restart

  • Open source nginx: 1.31.9 (mainline) or 1.30.7 (stable), or newer.
  • NGINX Plus: 37.0.8.1 or 37.3.0.1.
  • Distributions: apply the security packages (Ubuntu, Debian), then check with step 4. For the RHEL family, watch your vendor's advisory.
  • Images and appliances: rebuild images on a fixed base and ask vendors whose products embed nginx for a fix.
  • Restart nginx (not just a reload), then check with step 5.

2. If an immediate update is not possible

The measures below are those of Xint, Wiz and Cloudflare. They are partial and do not replace updating. We only tested disabling HTTP/2; the others are reported as these sources describe them.

  • Disable HTTP/2: http2 off; in the relevant server blocks from 1.25.1, or remove http2 from the listen directive on older versions. Reload, then make sure the old workers have stopped. This blocks CVE-2026-123007 and CVE-2026-123633. We verified it: the client falls back to HTTP/1.1. Services that require HTTP/2 (native gRPC, for example) will stop working.
  • HTTP/3 (CVE-2026-121810): remove the QUIC listeners, set http3 off and replace the Alt-Svc header with Alt-Svc 'clear' (Xint).
  • Mail proxy (CVE-2026-113425): listen on loopback only, or filter the IMAP, POP3 and SMTP ports with a firewall (Xint).
  • Resolver (CVE-2026-123634): use a fixed upstream group rather than a proxy_pass built from the request, including for mirror (Xint).
  • SCTP kernel flaw: on hosts that do not use SCTP, Xint recommends blocking the module from loading by placing the line install sctp /bin/false in a file under /etc/modprobe.d/. We did not test this line. It does not unload a module that is already loaded and does not apply if SCTP is built into the kernel. To find out:
grep -w sctp /proc/modules
grep -E 'CONFIG_IP_SCTP=' /boot/config-$(uname -r)

The first command tells whether the module is loaded. The second gives m (module) or y (built into the kernel). We ran them on a Linux workstation: module not loaded, CONFIG_IP_SCTP=m.

3. Take inventory

The difficulty is knowing where nginx is: servers, reverse proxies, containers and base images, ingress controllers, appliances, vendor software. A component inventory (SBOM) and monitoring of the exposed surface, for example with an EASM approach, are the condition for reacting quickly to the next flaw of this kind. If you use ingress-nginx, plan its migration: the Kubernetes project recommends moving to a maintained solution.


Why so many critical flaws in so little time?

These flaws are not new: CVE-2026-123007 has been in nginx since HTTP/2 arrived in 2015, the SCTP kernel flaw since 2018, and Java4Shell since OpenJDK 17.0.6 (according to Calif). What has changed is the speed at which they are found, and several players note it, researchers and threat analysts alike:

  • Xint states that one of its researchers found nginx's main flaw, then that its automated analysis tool found the other four "without human guidance". According to Xint, the nginx security advisory page listed two vulnerabilities for the whole of 2025, against 26 between January and 17 November 2026, before NGINX2Root.
  • Wiz used analysis tools and AI models to find two of the flaws and validate their impact.
  • Calif discovered Java4Shell, the OpenJDK flaw of 17 November, with OpenAI's Codex agent. According to Calif's figures as relayed by the press, the agent flagged the defect in about an hour, a first exploit followed in about two hours, for less than 200 dollars of compute. We could not verify these figures independently.
  • Google (GTIG and Mandiant), in its report of 16 November, describes for the first time a fully automated pipeline: an exposed server continuously analysed web application patches, wrote exploits and ran them with no human involvement. Its operator appeared to target French sites (media, entertainment, education). The report also cites PaperCut, where researchers produced working exploits within a day of disclosure and where GreyNoise saw a campaign four days later. This report covers neither nginx nor NGINX2Root: it describes a trend, not an attack against nginx.

One nuance: in these cases, human expertise remains central. AI speeds up research and validation, it does not replace the researchers who steer the analysis and build the exploitation chains. But when finding and then exploiting a flaw in a proven component takes hours, the delay between a fix being published and being applied becomes the deciding factor. Nothing prevents attackers from using the same tools: inventorying your engines and being able to fix them quickly now matter as much as the fix itself.


Our analysis

  • The hardest part is not the fix, it is knowing where nginx is. It is in servers, in images, in ingress controllers, in appliances. And the update only takes effect after the restart.
  • The conditions of the public exploit are slightly reassuring, but they do not protect you. 128 GB of traffic is costly for an isolated attacker, but not for a well-equipped actor or from an internal network. Three teams have demonstrated code execution, and a public exploit exists: the gap between "difficult" and "impossible" narrows over time.
  • Severity labels diverge. Between "major", "medium" and "critical", prioritisation goes through actual exposure (HTTP/2, reachable port, CDN or not), not through the score.
  • Distributions do not move at the same pace. Ubuntu published its notice on 19 November and Debian offers security packages, whereas the Rocky Linux 9 package changelog does not yet mention the CVE. A version number is not enough: check the package changelog.
  • Containers do not protect you from the kernel. The chain announced by Xint is a reminder that a compromised container can reach the host when the kernel is vulnerable. This also applies to your other exposed containers.

After PHP2Shell and Node2Shell, this is the third core component hit in less than a month, in the same week as Java4Shell (OpenJDK, 17 November) and the PHP fixes of 19 November.

At AlgoSecure, we can help you map your exposure (with AlgoLightHouse, our EASM solution), check your exposed configurations as part of a penetration test and assess the impact of a compromise through an Assumed Breach approach. Also read our article on PHP2Shell.


Sources

You've enabled "Do Not Track" in your browser, we respect that choice and don't track your visit on our website.