CVE-2026-123007 (nginx2root): remote code execution in nginx's HTTP/2 module
nginx2root: five memory corruption flaws in nginx, including CVE-2026-123007 in HTTP/2, fixed in 1.31.9 and 1.30.7. Versions, checks, workarounds.

Background
On 18 November 2026, nginx shipped two releases on the same day: 1.31.9 on the mainline branch and 1.30.7 on the stable branch. The changelog for the first one has ten "Security" lines, which is a lot for a project that, by Xint's count, published only two advisories in the whole of 2025.
Five of those ten flaws come from the Xint research team. It disclosed them a few hours later under the name nginx2root, adding a sixth flaw, in the Linux kernel this time, that takes an attacker from the nginx account to root. Hence the name: you come in through the web server and end up owning the machine.
The one that concerns the most people is CVE-2026-123007. It is a bookkeeping error in HTTP/2 flow control, present for as long as nginx has spoken HTTP/2, that is since version 1.9.5 in 2015. It needs no exotic configuration. HTTP/2 only has to be enabled, which is common on an nginx that serves HTTPS.
We spent the day on the sources, and what struck us is that they do not tell the same story. Xint talks about demonstrated, unauthenticated code execution on the three big clouds. F5, which publishes nginx, talks about a worker process crash, with code execution conditional on bypassing ASLR. The nginx security page rates three of the five flaws as medium. This article tries to say which of those readings to go with when deciding what to do tonight.
One clarification before going further: we have not reproduced any of these flaws. Xint is not publishing its code, and we did not try to rewrite it. What follows comes from its publication, from the five CVE records issued by F5, from the nginx changelog and from the HTTP/2 fix, which we read. The F5 support articles the records point to remained out of our reach.
We revised this article the same evening, after reading two publications the first version lacked: those of Rapid7 and Wiz, which each found CVE-2026-123007 on their own. They change two things. Code execution is now described by three teams that were not working together, and Rapid7 has made an exploit public, which we have not run.
We revised it again on the morning of 19 November. Distributions split into two groups overnight: Ubuntu, Amazon Linux, Alpine and AlmaLinux published their packages, while Red Hat, Debian stable and SUSE still have nothing. Censys also described a test that tells a fixed nginx from a vulnerable one without Rapid7's volume of traffic. No attack has been reported, and the kernel flaw still has neither an identifier nor a fix.
A third revision followed on 20 November. Debian published its packages for releases 12 and 13 during the day of the 19th, and Apache APISIX shipped a release that bundles nginx 1.31.9. Red Hat still has no erratum, but opened a dedicated bulletin. Nothing else has moved: no attack reported, no KEV listing, nothing new on the kernel.
The video below sums up the flaw in two minutes. The rest of the article goes through each point in detail, with its sources.
Technical summary
| Item | Value |
|---|---|
| Identifier | CVE-2026-123007, assigned by F5 |
| Component | ngx_http_v2_module, send-side flow control |
| Class | CWE-191 (integer underflow) and CWE-787 (out-of-bounds write) |
| Severity | CVSS 4.0 of 9.2 and CVSS 3.1 of 8.1 for F5. "Major" on the nginx security page |
| Affected versions | nginx 1.9.5 to 1.31.8 |
| Fix | nginx 1.31.9 and 1.30.7, released on 18 November 2026 |
| Condition | HTTP/2 enabled on a port the attacker can reach |
| Discovery | Xint, Stephen Fewer (Rapid7), Tomer Schwartz (Wiz Research) and Ikotas Labs, all credited by F5 |
| Exploitation | Public exploit (Rapid7); no attack reported as of 20 November, absent from the KEV catalog |
F5 gives the five flaws exactly the same score and the same vector, CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H. Everything hinges on AC:H, high attack complexity, which the descriptions justify as follows: code execution is possible "when ASLR is disabled or the attacker can bypass ASLR". In other words, for F5, the normal outcome is a process that crashes and that nginx restarts.
Xint answers that reservation in its analysis, without quoting it. For each of the five flaws, the team describes how it first obtains a memory address leak, then uses it. If that is accurate, F5's condition is lifted by the flaw itself, and AC:H describes the attacker's workload more than a protection for the victim.
Xint is no longer alone in saying so. Wiz writes that it bypassed ASLR on the official 1.31.7 and 1.31.8 builds, and Rapid7 explains that the out-of-bounds read hands over precisely the pointers ASLR is meant to hide. When three teams separately reach the same conclusion, we see no reason left to stick to F5's reservation.
For CVE-2026-123007, we therefore go with the researchers' reading, and we would treat it as critical on an exposed nginx that negotiates HTTP/2. We would be more measured about the other four, which need configurations you do not meet everywhere. The method we follow for this kind of call is described in our article on vulnerability prioritization.
Affected systems
The five flaws have nothing in common apart from who found them. None depends on another, and each assumes a different configuration. The version ranges below are those of the nginx security page.
| CVE | Component | Exposed configuration | Affected versions | Severity (nginx) |
|---|---|---|---|---|
| CVE-2026-123007 | HTTP/2, flow control | HTTP/2 enabled | 1.9.5 to 1.31.8 | major |
| CVE-2026-123633 | HTTP/2 | HTTP/2 on the client side and requests proxied to an upstream server | 1.19.7 to 1.31.8 | medium |
| CVE-2026-121810 | HTTP/3 | HTTP/3 (QUIC) and requests proxied to an upstream server | 1.25.0 to 1.31.8 | medium |
| CVE-2026-123634 | DNS resolver | resolver, a proxy_pass containing a variable, and a subrequest (mirror, SSI) | 0.6.18 to 1.31.8 | medium |
| CVE-2026-113425 | Mail proxy | mail block with proxy on and auth_http | 0.5.33 to 1.31.8 | major |
A few reading notes, because the sources were published in a hurry and it shows. The CVE-2026-121810 record gives "1.25.09" as the first affected version, a typo for 1.25.0. For the resolver and the mail proxy, Xint quotes higher lower bounds than nginx does (1.13.4 and 0.5.15): those are the first versions where its attack path works, not the ones where the bug appears. For an inventory, we would take the nginx ranges, which are the widest.
The two flaws that go through an upstream server (CVE-2026-123633 and CVE-2026-121810) have one more condition, which the changelog words like this: the process must be short of worker_connections. That sounds like a rare circumstance. Xint explains that an attacker creates it by opening enough connections, which makes it a step of the attack rather than an accident of operations.
Finally, being outside the CVE-2026-123007 range says nothing about the others. An old nginx built without HTTP/2 escapes the main flaw and is still affected by the resolver and mail proxy ones, which go back to the 0.x series.
NGINX Plus
The CVE records give 37.3.0.1 for the 37.1 line and later, and 37.0.8.1 for the 37.0 line. The CVE-2026-123633 record shows other numbers (37.2.0.1 and 37.0.7.1). We wondered whether that was intended, and it is: Wiz gives the same ones, that flaw was simply fixed one release before the other. To be covered on both, aim for the higher numbers.
The R33 line is marked affected, with no fixed version, and Rapid7 finds none for R34 to R36 either. Having been unable to read F5's support articles, we will go no further: F5 is where to check before planning.
Read those numbers at F5 and nowhere else. The CERT-FR advisory of 18 November (CERTFR-2026-AVI-1567), which groups twenty-two flaws in F5 products, writes "NGINX Plus versions 3.1.x à 3.2.x antérieures à 3.7.3.0.1". It should presumably read 37.1.x, 37.2.x and 37.3.0.1: the dots have slipped. That is harmless to anyone who knows the product, and misleading to a tool that compares versions from that text.
Distributions
This is where the version number becomes misleading. Debian 12 ships nginx 1.22.1, Ubuntu 24.04 ships 1.24.0, and those numbers will not move on the day the fix lands: only the package revision will change. nginx -v will still print 1.24.0 on a fixed server.
| Distribution | Status recorded on the morning of 20 November 2026 |
|---|---|
| Ubuntu 22.04 to 26.10 | Fixed (USN-9159-1): 1.18.0-6ubuntu14.23, 1.24.0-2ubuntu7.20, 1.28.3-2ubuntu1.13, 1.30.4-7ubuntu1.2 |
| Ubuntu 16.04 to 20.04 | Fixed, under an Ubuntu Pro subscription |
| Ubuntu 14.04 | Not affected by CVE-2026-123007 |
| Amazon Linux 2023, 2 | Fixed in nginx-1.30.7-1 (ALAS2023-2026-3494 and ALAS2NGINX1-2026-018) |
| Alpine | Fixed: 1.30.7-r0 (3.24, edge) and 1.28.3-r8 (3.22, 3.23) |
| AlmaLinux 8, 9, 10 | Fixed since the evening of 18 November, ahead of Red Hat |
| Debian sid | Fixed in 1.30.6-4 |
| Debian 13 | Fixed in 1.26.3-3+deb13u11 (DSA-6642-1) |
| Debian 12 | Fixed in 1.22.1-9+deb12u11 (DLA-4918-1) |
| Debian forky | Marked vulnerable (1.30.6-3) |
| Red Hat | No erratum, rated "critical"; bulletin RHSB-2026-019, which advises turning HTTP/2 off meanwhile |
| SUSE | Tumbleweed fixed (1.31.9-1.1); fixes in preparation for SLES 15 SP7 and 16, no advisory published |
The table illustrates what we said about the version number. On Ubuntu 24.04, the fixed package is called 1.24.0-2ubuntu7.20. nginx -v still answers 1.24.0 there, as it did the day before, and as it does on a server that has not been updated.
AlmaLinux got ahead of the distribution it derives from, which is rare enough to note. Its post from the evening of 18 November says so plainly: Red Hat had not released fixed packages at that point. It also flags a trap for AlmaLinux 8, and therefore for RHEL 8: the nginx:1.14 stream, still the default there, is retired and will get nothing. A server left on that stream has to switch before it can be fixed.
The Ubuntu 14.04 case is instructive. Its nginx 1.4.6 has SPDY rather than HTTP/2, and Ubuntu's security team notes that this SPDY/2 module has no flow control at all: the send window only arrives with SPDY/3.1, in 1.5.10.
Debian joined the first group during the day of 19 November, with a DSA for release 13 and an advisory from the LTS team for release 12. Both version numbers, 1.26.3 and 1.22.1, are the ones from before: this is the case described above. That leaves Red Hat as the last major absentee. Its bulletin RHSB-2026-019, opened on 19 November, lists every product concerned as affected and offers workarounds only.
Our check covers CVE-2026-123007. Ubuntu's notice covers eight flaws, including the five of nginx2root, and Amazon Linux's cover nine. We did not check Fedora or the Debian derivatives.
The official Docker images moved faster. According to the same tracker, nginx:latest and nginx:mainline have pointed to 1.31.9 and nginx:stable to 1.30.7 since late afternoon on 18 November, and nginx:alpine followed half an hour later. An image pulled before that is still the old one, and a running container does not change image by itself.
That leaves everything that embeds nginx without saying so: Kubernetes ingress controllers, OpenResty, a good many load balancers and appliances. There, neither nginx -v nor our table is of any use, and you have to wait for the vendor's advisory.
Precursor's tracker gives an idea of the extent, although we have not cross-checked these points with each vendor. The community ingress-nginx controller is no longer maintained and will not get a fix. F5's own controller still shipped nginx 1.31.8 in its version 5.8.0. The Metnir researchers say they reproduced the bug in OpenResty and crashed shipped builds of Kong and Apache APISIX. On these products, HTTP/2 is turned off in their own configuration (use-http2: "false" for ingress-nginx), not in an nginx.conf file.
We looked at these projects' repositories on the morning of the 19th, and none had a fixed release to install at that point. Things have moved for one of them only. Apache APISIX published version 3.21.0 on the afternoon of 19 November: its runtime moves to the nginx 1.31.9 core, and the release notes cite the two HTTP/2 flaws, the HTTP/3 one and the resolver one. Kong had merged its fixes during the night of the 18th, for the two HTTP/2 flaws only; a version 3.9.5 has come out since, but its page cites neither the CVEs nor HTTP/2, and we cannot say whether it contains them. OpenResty has an update request open and no answer from its maintainers. F5's controller is still at version 5.8.0. APISIX aside, turning HTTP/2 off remains the only measure available today.
How it works
We describe CVE-2026-123007 here from the fix commit, and the other four from Xint's publication. We stop at the memory corruption: what comes after, up to code execution, is in Xint's analysis and we have nothing to add to it.
HTTP/2 flow control
HTTP/2 runs several exchanges inside a single connection, each in its own stream. To keep a server from drowning a slow client, the protocol imposes a send credit, counted in bytes: one window per stream, and one for the whole connection. The server spends that credit by sending data, and the client tops it up with a WINDOW_UPDATE frame.
That credit has a cap, 2^31 - 1 bytes, and a client that tries to exceed it commits a protocol error. nginx did check that cap on every WINDOW_UPDATE. The bug is elsewhere.
A credit counted twice
nginx debits the connection window when it puts data in the queue, not when the data actually leaves on the network. If the client cancels the stream in the meantime, nginx removes the data from the queue and credits the window back by its length. Up to that point, the books balance.
The trouble is that the client can act in between. While data is waiting, it tops the window up to the cap: that is legal, since the matching credit has just been debited. It then cancels the stream. nginx hands back a credit the client had already recovered on its own, and the window goes above the maximum without any check standing in the way.
Once the window is out of bounds, everything computed from it becomes wrong. The commit message speaks of "broken buffer size control" in ngx_http_v2_send_chain(), then of memory corruption. Xint details how one leads to the other: an invalid copy length in the TLS output path, hence a read and a write outside the process's buffers.
From an HTTP/2 connection to root on the host
- 1
HTTP/2 connection
the attacker opens a TLS connection and negotiates HTTP/2, without authentication.
- 2
Window past the cap
they top up the connection window while data is queued, then cancel the streams.
- 3
Memory corruption
a copy of invalid length reads and writes outside the worker process's buffers.
- 4
Code execution
with the disclosed addresses, the attacker runs commands under the worker process account.
Root on the host
a separate Linux kernel flaw (SCTP) yields root, including from inside a container.
What the fix changes
The fix is short: a handful of lines in three files (commit b89c410, authored by Roman Arutyunyan and dated 29 October). nginx now keeps a second counter, send_queued, which totals what is queued and has not left yet. When a WINDOW_UPDATE arrives, the increment is compared with what remains once that counter is deducted.
The idea is in the last sentence of the commit message: from the client's point of view, the queued frames still belong to the flow control window. So the fix addresses the bookkeeping itself rather than its consequences, which seems to us the right approach.
The four use-after-free bugs
The other four flaws are from the same family (CWE-416): nginx frees a structure while another piece of code still expects to use it.
Two of them, CVE-2026-123633 and CVE-2026-121810, look very much alike. When a process has no free connections left, nginx reclaims some by closing the ones that are doing nothing. But an HTTP/2 connection, or a QUIC one in the second case, could stay labelled "reclaimable" while a request was being processed on it. That request opens a connection to the upstream server, which triggers the reclaiming, which closes the request's own connection. The code then carries on with memory it has just freed.
CVE-2026-123634 is in the DNS resolver. If a request and its subrequest are waiting for the same name to resolve, the end of the first can free the context of the second, which the resolver loop processes right after. Xint showed it with mirror, and F5 also mentions SSI includes. Removing mirror is therefore not enough to be safe.
CVE-2026-113425 affects the mail proxy, a module that is not widely used. When the client drops, nginx frees its session, while the connection opened to the authentication service (auth_http) still points to it. The point that matters to an operator: this happens during authentication, so without valid credentials.
Exploitation status
Xint says it has no evidence of exploitation so far, while pointing out that some of these bugs are more than ten years old and that prior use cannot be ruled out. The team is keeping its code to itself, the risk being judged too high, and Wiz is doing the same. Rapid7 made the opposite choice: on 18 November its researcher published, along with his analysis, a complete exploit for CVE-2026-123007. We have not run it.
What it describes goes beyond a lab proof of concept. For CVE-2026-123007, command execution was obtained from an ordinary TLS port, while the server was handling normal traffic, on AWS, GCP and Azure, including through a public HTTPS address. The other four flaws were validated on the official nginx:1.31.8 Docker image, to which the team added the required configuration.
Rapid7's publication is also the most precise about what the attack costs. Its demonstration targets the nginx 1.31.8 Docker image, with TLS and HTTP/2, and succeeds in about two and a half minutes. It requires pushing roughly 128 GB of HTTP/2 traffic through a single connection: two minutes on a 10 Gbit/s link, seventeen at 1 Gbit/s, and below about 300 Mbit/s the default lifetime of an nginx connection, one hour, runs out before the end. It also depends on a variant of glibc's copy routine that the system only selects on some recent x86-64 processors. The resulting code runs with the worker process's privileges, and does not reach root.
These figures can look reassuring, and that would be jumping ahead. They hold for the method Rapid7 chose, and the team itself writes that other strategies may be viable. Neither Xint nor Wiz publishes the constraints of theirs, and Xint states that it succeeded from a public HTTPS address. A 1 Gbit/s link to a machine rented in the same data centre as the target is nothing unusual either. The main value of these figures is for detection, which we come back to below.
What worries us most is the number of finders. The CVE-2026-123007 record thanks four, and Wiz counts five for the two HTTP/2 flaws: Xint, Rapid7, Ikotas Labs, Metnir and itself. The nginx changelog, for that matter, attributes CVE-2026-123633 to a researcher who is not from Xint. The dates point the same way: Xint reports CVE-2026-123007 in mid-October, Rapid7 finds it again on 11 November, and Wiz sends it to F5 on the 16th, two days before the release of a fix written three weeks earlier. When that many people stumble on the same bug in so little time, you have to assume that others, less talkative, found it too.
The fix is public, it names the function and the condition, and code that works in a lab has been circulating since day one. So we would not bet on the few weeks of respite that usually separate an advisory from the first attacks. And there is no need to go all the way to code execution to do damage: knocking an nginx's worker processes over in a loop is a much shorter step.
Since then, Censys has published work that changes how Rapid7's figures should be read. Its team describes a short test, over cleartext HTTP/2, that brings the connection window into the faulty state and then watches the server's reaction: a vulnerable nginx accepts the sequence, 1.31.9 rejects it and closes the connection. Censys writes that the test does not corrupt memory and that it serves to validate a fix without producing tens of gigabytes of traffic. It is meant for an isolated lab, its TLS variant is not validated, and we have not tried it.
What we take from it fits in one sentence: the 128 GB is the price of code execution by Rapid7's method, not the price of reaching the bug. Putting the window out of bounds takes only a few frames. Censys also crashed worker processes with three of the four other flaws on an official 1.31.8 image, without reproducing the HTTP/3 one. The denial of service we mentioned above is therefore no longer a hypothesis.
Some twenty repositories appeared on GitHub within twenty-four hours. One of them claims to have replayed code execution without the processor constraint Rapid7 describes, and on a version for which Rapid7 supplies no profile. We ran none of this, and none of these claims is confirmed by a known team. They do point the way we expected: the limits of the first published method do not hold for long.
On the attack side, nothing new. The SANS Internet Storm Center reported neither scanning nor attempts on its honeypots on the evening of the 18th, and the assessment CISA attaches to the CVE record still reads "exploitation: none". Censys puts it better than we do: a point-in-time absence of evidence, not proof that no attacks have occurred.
One practical warning to finish. Precursor's tracker reports fake "exploits" appearing on GitHub in the hours after the announcement. Those repositories are not something to run against your own server: at best they do nothing, at worst they trap whoever executes them.
A last word on the figure doing the rounds. On 10 November Xint counted 56.7 million nginx hosts on Shodan, of which 11.94 million display their version, and 98.9% of those are in the CVE-2026-123007 range. That percentage measures banners. It does not know whether HTTP/2 is enabled or whether a fix has been backported, which Xint itself states in so many words. It is not the number of exploitable servers.
Checking a server
For CVE-2026-123007, three questions are enough: is the version fixed, is the HTTP/2 module compiled in, is HTTP/2 enabled?
# Version and HTTP/2 module
nginx -v
nginx -V 2>&1 | grep -o -- '--with-http_v2_module'
# HTTP/2 enabled in the configuration read from disk
sudo nginx -T 2>/dev/null | sed 's/#.*//' \
| grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'Mind nginx -T: it reads the files, not the process's memory. On a server whose configuration was edited without a reload, what it prints is not what is running.
The most reliable test is still the one made from the outside, because it shows what an attacker sees:
openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>&1 \
| grep -E 'ALPN protocol|No ALPN negotiated'ALPN protocol: h2 means the port accepts HTTP/2. Behind a CDN or a load balancer, this command queries the front end and not nginx: it has to be run again against the origin server directly.
For the other four flaws, nothing shows from the outside and everything is read in the configuration. Look for quic or http3 on, a proxy_pass containing a variable where a resolver directive is present, and a mail block with auth_http.
Remediation
Move to nginx 1.31.9 or 1.30.7, or install the distribution's fixed package as soon as it is out.
One trap comes back with every nginx update, and it counts double today. nginx -s reload re-reads the configuration but keeps the binary that is in memory. After installing the package, what is needed is a service restart (or the live binary upgrade procedure), followed by a look at ps to make sure no old process is hanging around.
Workarounds
Until the fix is in place, the paths can be closed one by one. None of these measures is worth the update, and they only make sense in the meantime.
For the two HTTP/2 flaws (CVE-2026-123007 and CVE-2026-123633), turn HTTP/2 off on exposed ports. The syntax depends on the version: from nginx 1.25.1 onward you write http2 off; in each server block and drop the http2 parameter from listen directives, whereas before that it is enough to remove it from listen 443 ssl http2;. Browsers fall back to HTTP/1.1 without the user noticing. gRPC, on the other hand, needs HTTP/2 and stops working: that is the thing to check before touching an API server. Wiz and Red Hat give the same instruction.
For CVE-2026-121810, remove the listen lines that carry quic, add http3 off;, and replace the Alt-Svc header advertising HTTP/3 with Alt-Svc 'clear', otherwise browsers keep trying QUIC. Blocking UDP on that port at the firewall costs nothing more.
For CVE-2026-123634, replace the variable-based proxy_pass with a fixed upstream group, which removes the DNS lookup at request time. Xint reports that mirror_request_body on stopped its code without fixing the bug, and recommends not settling for it. We would follow that advice.
For CVE-2026-113425, close off access to the mail proxy: listen on the loopback address if it only serves programs on the same machine, filter by address at the firewall otherwise.
In every case, a reload is not enough to cut connections that are already open. The old worker processes keep serving their HTTP/2 connections with the old configuration, and show up in ps as worker process is shutting down. Only a restart closes them, at the cost of a short interruption.
We would not count on a web application firewall. Its rules read URLs and request bodies, whereas the bug plays out in HTTP/2 control frames it does not look at. A front end that terminates HTTP/2 and speaks HTTP/1.1 to nginx does cut the path, though, provided nginx can no longer be reached directly by its address. If the front end speaks HTTP/2 to nginx, the answer is less clear-cut: Rapid7 considers it unlikely that the frames the attack needs are relayed as is, and Wiz only writes that a CDN may mitigate part of it, depending on its implementation. We would not treat that as a protection.
The kernel flaw
The privilege escalation lies in the SCTP subsystem of the Linux kernel. Xint states that the bug dates from version 4.15, released in 2018, and that a fix should arrive in the coming weeks. There is no CVE yet, and the team is holding the details back.
Nothing had moved by the morning of 19 November. The question was asked on the oss-security list overnight, and the answer fits on one line: the kernel has not patched this bug. Announcing a kernel flaw with neither a fix nor an identifier leaves operators in an awkward spot, since they know a bug exists in a specific module and have nothing to install. That is one more reason to apply the measure below without waiting.
Very few web servers need SCTP. On those that do not, loading the module can be forbidden:
echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf
lsmod | grep sctpThe first line blocks loading through modprobe. It does not unload a module already in memory (that is what the second command shows) and has no effect if SCTP is compiled into the kernel.
This flaw deserves attention even on a machine where nginx is up to date. It serves anyone already running code on the system, whichever way they got in. It also strips the container of its role as a barrier: all containers on a host share its kernel, and Xint says it got out of a Docker container this way.
Looking for signs of compromise
The guidance in this section comes from Xint, supplemented by Wiz and Rapid7. We have not had the opportunity to test it against a real attack, and we pass it on for what it is.
Expect nothing from access logs. The WINDOW_UPDATE and RST_STREAM frames that trigger CVE-2026-123007 are not requests, nginx does not log them, and TLS keeps them from being seen on the network. A successful attack may not leave a single line.
The best indicator is what the process does afterwards. An nginx worker process serves files and relays requests, it never starts a program. An auditd rule on execve, filtered on the nginx account's UID, records any exception:
ps -eo uid,user,pid,args | grep '[n]ginx: worker process'
sudo auditctl -a always,exit -F arch=b64 -S execve,execveat -F euid=NGINX_UID -k nginx_worker_exec
sudo ausearch -k nginx_worker_exec -ts recent -iThat rule only sees the future. Installed today, it will say nothing about yesterday's compromise.
Crashes are the other lead, because a failed attempt often brings a process down:
sudo grep -Ei 'worker process.*exited|signal 11|segfault' /var/log/nginx/error.log
sudo coredumpctl list nginxA single crash proves nothing, nginx has them for other reasons. What would make us react is a run of crashes close together with, from one address, a connection that lasts several minutes, receives a lot and sends almost nothing back. That is the profile Xint describes, and ss -tinp lets you measure it.
The volume given by Rapid7 provides an order of magnitude. A single HTTP/2 connection exchanging tens of gigabytes with a server of web pages has no ordinary explanation, and Wiz too recommends watching for long-lived, high-volume HTTP/2 connections. Per-connection throughput figures, taken on a load balancer or a network probe, can therefore show what nginx's logs do not. This marker holds for the published method. Another one could be quieter.
If you find a program started by an nginx process, updating no longer solves the problem. Whatever that account could read (TLS private keys, tokens for upstream services) has to be rotated and, for as long as the kernel flaw is unfixed, you have to consider that the whole machine may be compromised.
Timeline
nginx2root timeline
Report
11 October 2026
Discovery
the Xint team identifies the flaws while preparing for the ZeroDay Cloud 2026 competition.
16 October 2026
Report to F5
sent through HackerOne, validated on 20 October and passed to the nginx team on the 27th.
Fix
29 October 2026
HTTP/2 fix commit
author date of commit b89c410, which adds the send_queued counter.
9 November 2026
Fix validation
F5 reserves the CVE-2026-123007 identifier. The nginx team asks Xint to validate the fixes, which is done on the 10th.
11 November 2026
Other reports
Rapid7 finds CVE-2026-123007 on its own and notifies F5. Wiz does the same on the 16th.
Publication
18 November 2026
nginx 1.31.9 and 1.30.7
release of both versions and of the security page.
18 November 2026, 15
CVE records
F5 publishes the five records. Xint, Wiz and Rapid7 publish their analyses the same day, Rapid7 with its code.
Aftermath
18 November 2026, evening
First packages
Amazon Linux 2023 and AlmaLinux publish their fixes. Censys describes a test that identifies a fixed server.
19 November 2026
Ubuntu
notice USN-9159-1, fixed packages for every tracked release.
19 November 2026, during the day
Debian and APISIX
DSA-6642-1 for Debian 13, DLA-4918-1 for Debian 12, and Apache APISIX 3.21.0 on nginx 1.31.9. Red Hat opens a bulletin, with no erratum.
The HTTP/2 fix commit carries an author date only two days later than the handover of the report to the nginx team.
The other fixes in 1.31.9
Of the ten security fixes in 1.31.9, five do not belong to nginx2root. The one that deserves attention is CVE-2026-118899, rated "major": a worker process can spin in an endless loop while reading a request body over TLS 1.3. Versions 1.13.0 to 1.31.8 are affected, and a denial of service of that kind is simpler to trigger than a memory corruption.
The other four are of medium or minor severity: a buffer overflow with alias and try_files (CVE-2026-125283), a client certificate verified with the wrong server's configuration in the stream module (CVE-2026-120967), a divergent reading of the ClientHello in ngx_stream_ssl_preread_module (CVE-2026-123640), and a null pointer with PROXY protocol version 2, which only affects the 1.31 branch (CVE-2026-120993).
What can be checked from the outside
We have added an nginx scan to our free tools. It reads the server's Server banner and places the announced version against the ranges in this article.
Its limits need stating plainly, and they are those of any remote check for this flaw. It does not test the flaw, it does not know whether HTTP/2 is enabled behind a CDN, and on a distribution it cannot tell whether the package has received the fix. When the banner carries a distribution's mark, it says so instead of concluding. And when server_tokens off hides the version, it says nothing at all.
So it is mostly useful for finding the nginx servers you had forgotten about. The rest of the check happens on the machine, with the commands given above. For the overall method, see our article on inventorying your external attack surface.
Frequently asked questions about nginx2root
What is nginx2root?
It is the name Xint gave to six flaws published on 18 November 2026: five in nginx (CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810 and CVE-2026-113425) and one in the Linux kernel. According to Xint, each of the first five allows remote code execution, and the sixth allows becoming root afterwards.
Which nginx versions are affected?
From 1.9.5 to 1.31.8 for CVE-2026-123007. The other four flaws have wider ranges, down to 0.5.33 for the oldest. Versions 1.31.9 and 1.30.7 fix them all.
Is my server affected if HTTP/2 is disabled?
It escapes CVE-2026-123007 and CVE-2026-123633. The other three flaws (DNS resolver, HTTP/3, mail proxy) do not go through HTTP/2 and are checked in the configuration.
Can the number shown by nginx -v be trusted?
Not on Debian or Ubuntu, which fix while keeping the original version number. Compare the full package version (dpkg -l nginx) with the one in the distribution's security advisory. On Ubuntu 24.04, for instance, the fixed package is 1.24.0-2ubuntu7.20; on Debian 12, it is 1.22.1-9+deb12u11.
Do a CDN or a container protect?
A CDN protects against the two HTTP/2 flaws if it speaks HTTP/1.1 to nginx and if nginx cannot be reached directly. A container limits what a compromised process can see, but the kernel flaw described by Xint makes it possible to get out.
Are the flaws being exploited?
No attack has been reported as of 20 November 2026 and the five CVEs are absent from the KEV catalog. Rapid7 has, however, published an exploit for CVE-2026-123007, which needs a very large volume of traffic and was shown on a lab configuration. Xint and Wiz are keeping theirs. Censys has shown that reaching the bug, short of code execution, takes only a few frames.
Sources
- nginx, security advisories
- nginx, changelog for 1.31.9
- nginx, changelog for the 1.30 branch
- nginx/nginx repository, commit b89c410, "HTTP/2: account for queued frames when validating WINDOW_UPDATE"
- Xint, "NGINX2Root: New Remote Code Execution Vulnerabilities in nginx Require Urgent Patching"
- nginx2root.com
- Rapid7, "CVE-2026-123007: Critical NGINX HTTP/2 Integer Underflow Leads to RCE"
- Wiz, "Unauthenticated Remote Code Execution in NGINX: CVE-2026-123633 and CVE-2026-123007"
- Precursor Security, hour-by-hour nginx2root tracker
- CVE-2026-123007 record
- CVE-2026-123634 record
- CVE-2026-123633 record
- CVE-2026-121810 record
- CVE-2026-113425 record
- Censys, "nginx2root: A simple test for the HTTP/2 flaw and three use-after-free reproductions"
- Ubuntu, notice USN-9159-1
- Amazon Linux, tracker for CVE-2026-123007
- Alpine, tracker for CVE-2026-123007
- AlmaLinux, 18 November 2026 post on nginx2root
- SUSE, CVE-2026-123007 page
- CERT-FR, advisory CERTFR-2026-AVI-1567
- oss-security, thread on the kernel SCTP flaw, 18 and 19 November 2026
- SANS Internet Storm Center, diary of 18 November 2026
- Debian, security tracker for CVE-2026-123007
- Debian LTS, advisory DLA-4918-1 (nginx, Debian 12)
- Red Hat, bulletin RHSB-2026-019
- SUSE, record for CVE-2026-123007
- Apache APISIX 3.21.0, release notes
- Ubuntu, CVE-2026-123007
- Red Hat, CVE-2026-123007
- CISA, Known Exploited Vulnerabilities catalog
Let’s discuss your external exposure
Request a personalized Flawfence demo and discover your real exposure level.
