19 November 2026 Hacks Florant Montel

NGINX2Root (CVE-2026-123007): check and patch nginx, without panicking

NGINX2Root: the short answer (TL;DR)

On November 18, 2026, nginx fixed five vulnerabilities grouped under the name NGINX2Root. The most severe, CVE-2026-123007, affects HTTP/2. On paper, it lets an attacker run code on the server without an account. In practice, the attack is heavy, noisy and tied to specific hardware. No need to panic, then, but a fix to plan: update to nginx 1.30.7 or 1.31.9, and disable HTTP/2 in the meantime if the update has to wait.

  • What is affected: open source nginx from 1.9.5 to 1.31.8 with HTTP/2 enabled, and NGINX Plus before 37.0.8.1 and 37.3.0.1.

  • Why it is hard: the only public attack sends about 128 GB over a single connection and only works on certain x86-64 processors. The researchers who have a more advanced method are keeping it to themselves, and consider this type of vulnerability hard to exploit remotely.

  • And the root step? It requires a second vulnerability, in the Linux kernel. It is not fixed yet, but one line of configuration blocks it.

  • Exploitation: a proof of concept works in the lab. No exploitation in the wild has been reported, and the vulnerability is not in the CISA KEV catalog.

  • What to do first: patch the internet-facing nginx servers whose vulnerable version is visible, then check internally the ones whose version is hidden.

  • Workaround: http2 off; covers CVE-2026-123007 and CVE-2026-123633. The other three CVEs require rare configurations.

What is the NGINX2Root vulnerability (CVE-2026-123007)?

NGINX2Root (CVE-2026-123007) is a memory corruption vulnerability in nginx's HTTP/2 flow control, published on November 18, 2026. It is rated 9.2 in CVSS 4.0. The same vector indicates high attack complexity and prerequisites on the target side. Under certain conditions, it allows unauthenticated remote code execution (RCE). The name also covers four other nginx CVEs fixed the same day.

Why is NGINX2Root hard to exploit in practice?

The 9.2 score describes the worst case. The researchers who published the attack detail its limits themselves.

  • A huge volume over a single connection. Rapid7's proof of concept sends about 128 GB of HTTP/2 traffic over a single connection. That takes about 2 minutes on a 10 Gbit/s link and 17 minutes at 1 Gbit/s. Below about 300 Mbit/s, the attack fails: by default, nginx closes any connection after one hour.

  • Specific hardware for the public attack. Rapid7's proof of concept relies on a particular version of the glibc memory copy, selected on x86-64 processors that have AVX-512 instructions. Elsewhere, it crashes the worker process, which restarts immediately. Wiz Research reports running code on the official nginx 1.31.7 and 1.31.8 binaries, with another method it has not published.

  • Demanding exploitation. Wiz points out that these vulnerabilities "are difficult to exploit remotely". The attacker has to leak memory addresses, groom the heap and adapt to each version, build and configuration.

  • An attack that shows. A web page weighs a few megabytes. A connection that receives more than a hundred gigabytes stands out in any network monitoring.

  • A CDN acting as a shield. When a CDN or a proxy terminates the HTTP/2 connection, the attacker's frames are very likely not forwarded as is to nginx.

  • Limited privileges. The code runs with the privileges of the nginx worker (nginx or www-data), not root. Rapid7 did not obtain root access through this vulnerability alone.

  • An incomplete recipe. Xint, which named NGINX2Root, has held back the final steps of its exploits. Wiz does not publish its own.

This is no reason to wait. The fix is simple, and exploitation techniques improve over time. But NGINX2Root is not a vulnerability an attacker can launch at scale across the internet in a few hours. There is time to patch properly.

How does an attacker go from HTTP/2 to root with NGINX2Root?

HTTP/2 carries several streams over a single connection. To keep one stream from saturating the others, each side announces how much data it is willing to receive: this is flow control. When a stream is cancelled, nginx returns the unused window to the connection without checking the maximum set by HTTP/2. The counter overflows, and nginx ends up copying memory outside the intended bounds.

The full attack unfolds in three stages:

  1. The attacker opens an HTTP/2 connection to the server and, for several minutes, sends a very large number of frames crafted to trigger the error. No account is needed.

  2. The memory corruption gives code execution in the nginx worker process, which runs with limited privileges.

  3. Xint then chains a second vulnerability, in the Linux kernel SCTP module, to obtain root privileges on the host. Xint reports also succeeding from an nginx running in a Docker container, since all containers share the host kernel.

This kernel vulnerability has no fix and no CVE identifier yet. Xint is withholding the details until it is fixed. It can still be blocked simply: prevent the SCTP module from loading, which most web servers do not use (see "How to protect yourself").

Patching nginx closes the front door. Blocking the SCTP module closes the second stage, until a kernel fix is available.

The four other CVEs fixed the same day target less common configurations:

  • CVE-2026-123633 (HTTP/2): a reverse proxy whose free connection slots run out under a large number of attacker connections.

  • CVE-2026-121810 (HTTP/3): HTTP/3 enabled and nginx forwarding requests to an upstream server.

  • CVE-2026-123634 (DNS resolver): the resolver directive, a proxy_pass whose destination comes from the request, and the mirror directive, all together. The attacker must also control the DNS responses of a domain.

  • CVE-2026-113425 (mail module): the nginx mail proxy with auth_http, and an IMAP, POP3 or SMTP port reachable by the attacker.

Which nginx versions are vulnerable, and is NGINX2Root being exploited?

Claimed by the researchers. According to Xint, each of the five CVEs allows unauthenticated code execution in a given configuration. The full chain leads to root privileges through the Linux kernel SCTP vulnerability.

Independently confirmed. On November 18, 2026, the nginx team published the advisories for the five CVEs, their version ranges and the fixed versions 1.30.7 and 1.31.9. These two versions fix ten CVEs in total. Five teams found these vulnerabilities independently: Wiz Research, Ikotas Labs, Metnir, Rapid7 and Xint. Rapid7 published a proof of concept for CVE-2026-123007, with the limits described above. Wiz and Xint obtained code execution without publishing their method.

Not observed yet. As of November 18, 2026, no exploitation in the wild has been reported, and CVE-2026-123007 is not in the CISA KEV catalog. We are tracking both points and will update this article if they change.

Table 1: affected / not affected

CVEComponentVulnerable versionsSeverity (nginx advisory)Affected if
CVE-2026-123007HTTP/2 flow control1.9.5 to 1.31.8MajorHTTP/2 enabled. Every version since 2015.
CVE-2026-113425Mail proxy module0.5.33 to 1.31.8MajorMail proxy with reachable auth_http. mail block in the configuration.
CVE-2026-123633HTTP/2 (use-after-free)1.19.7 to 1.31.8MediumHTTP/2 enabled on a reverse proxy.
CVE-2026-121810HTTP/3 (use-after-free)1.25.0 to 1.31.8MediumHTTP/3 enabled (listen ... quic) and forwarding to an upstream server.
CVE-2026-123634DNS resolver0.6.18 to 1.31.8Mediumresolver and mirror directives, with a proxy_pass built from the request.
Not affectedAll five components1.30.7 and later, 1.31.9 and laterFixedFixed version installed and service restarted. Without HTTP/2, CVE-2026-123007 and CVE-2026-123633 do not apply.

Am I affected by the NGINX2Root vulnerability?

How do I check whether my nginx server is vulnerable?

  1. Note the nginx version.

nginx -v

Version 1.30.7, 1.31.9 or later downloaded from the official nginx website is fixed. For a distribution package, the displayed version may remain old even though the fix is applied: look for the CVE identifier in the package changelog.

# Debian, Ubuntu
apt changelog nginx 2>/dev/null | grep -m1 CVE-2026-123007
# RHEL, Rocky, Alma
rpm -q --changelog nginx | grep -m1 CVE-2026-123007

2.Check whether HTTP/2 or HTTP/3 is active.

sudo nginx -T 2>/dev/null | grep -nE "http2|listen[^;]*quic"

A http2 on; or listen 443 ssl http2; line indicates HTTP/2. A listen ... quic line indicates HTTP/3, affected by CVE-2026-121810.

  1. Look for the mail module, the resolver and the mirror.

3.Look for the mail module, the resolver and the mirror.

sudo nginx -T 2>/dev/null | grep -nE "^\s*(mail\s*\{|resolver\s|mirror\s|auth_http\s)"

4.Check whether the kernel SCTP module is loaded (the root escalation step).

lsmod | grep -w sctp
  1. List the containers that ship nginx.

docker ps --format '{{.Names}} {{.Image}}' | grep -i nginx
docker exec <conteneur> nginx -v

Kubernetes ingress controllers, appliance images and devices that embed nginx, including some F5 products, are updated through their vendor's patches, not through the system package manager: follow their advisories.

How do I find my nginx servers exposed to NGINX2Root from the internet?

Three pieces of information are enough to classify an exposed asset, and they can be gathered without sending an exploit.

Is HTTP/2 offered? The command prints 2 when HTTP/2 is negotiated.

curl -s -o /dev/null --http2 -w '%{http_version}\n' https://www.acme.example

Who answers, nginx or a CDN? A CDN-specific header indicates that the HTTP/2 connection most likely ends at the CDN, before reaching your nginx.

curl -sI https://www.acme.example | grep -iE '^(server|via|x-cache|cf-ray)'

Which version? Server: nginx/1.24.0 gives the version. Server: nginx with no number (server_tokens offdirective) calls for an internal check.

An asset that negotiates HTTP/2 and displays a vulnerable version goes to the top of the list. Hidden versions come next, then servers placed behind a CDN or a load balancer. For those, check whether nginx also accepts HTTP/2 directly, on its IP address. This is vulnerability prioritization applied to a single CVE.

How do I protect myself from NGINX2Root?

ProductFixed versionStatus as of November 18, 2026
nginx open source, stable1.30.7Available. Released by the nginx team on November 18, 2026.
nginx open source, mainline1.31.9Available. Released by the nginx team on November 18, 2026.
NGINX Plus, 37.0 branch37.0.8.1Available. See the F5 advisory.
NGINX Plus, 37.3 branch37.3.0.1Available. See the F5 advisory.
Official Docker imagesnginx:stable, nginx:mainlineUpdated on November 18, 2026. Pull the image again and redeploy the containers.
Linux distribution packagesDepends on the distributionBackported fix, each vendor on its own schedule. Look for the CVE in the package changelog.
Devices and products that embed nginxDepends on the vendorFollow the vendor advisory. Ingress controllers, appliances, F5 products.

Which nginx version fixes NGINX2Root?

Install nginx 1.30.7 (stable branch) or 1.31.9 (mainline branch), or your distribution package that contains the fix. Then restart the service: a simple reload rereads the configuration but keeps the old binary in memory.

sudo nginx -t && sudo systemctl restart nginx
nginx -v

For NGINX Plus, move to 37.0.8.1 on the 37.0 branch or to 37.3.0.1 on the 37.3 branch. Versions R34 to R36 do not receive a fix and must move to a maintained branch. For vendor devices and images, apply their patches. For a site on shared hosting, the fix depends on the hosting provider: follow up with them.

How do I disable HTTP/2 in nginx until the fix is applied?

Disable HTTP/2 in each server block (nginx 1.25.1 and later):

server {
    listen 443 ssl;
    http2 off;
}

On older versions, remove the http2 parameter from the listen directives: listen 443 ssl http2; becomes listen 443 ssl;. Test, then reload:

sudo nginx -t && sudo systemctl reload nginx

Browsers fall back to HTTP/1.1 on their own. gRPC services, which need HTTP/2, stop working: plan for it. This workaround covers CVE-2026-123007 and CVE-2026-123633. For HTTP/3, remove the listen ... quic directives. For the resolver, replace the proxy_pass built from the request with a fixed upstream, or remove mirror. For the mail module, restrict access to the mail ports with a firewall.

If HTTP/2 must stay active, shortening connection lifetime makes the attack more demanding in bandwidth. This setting fixes nothing; it only narrows the window.

keepalive_time 10m;

How do I block the root escalation until a kernel fix is available?

No Linux kernel fix is available for the SCTP vulnerability used by Xint. Prevent the SCTP module from loading; most web servers do not use it:

echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf
lsmod | grep -w sctp

This setting prevents the module from loading. It does not unload a module that is already loaded: if lsmod lists it, reboot the server after checking that no application uses SCTP. It does not apply if SCTP is compiled directly into the kernel. On a container host, apply it on the host: an nginx in a container shares the host kernel.

What should I do if an nginx server has already been compromised?

Rebuild it. The NGINX2Root chain can reach root privileges: a server suspected of compromise is rebuilt from a clean image. Then renew the TLS private keys and the secrets stored on the host.

How do I detect an NGINX2Root exploitation attempt?

  • A very long HTTP/2 connection that receives tens of gigabytes. This is the clearest sign of the public attack:

ss -tinp state established '( sport = :443 )'
  • Repeated worker process crashes in the error logs:

grep -E "worker process [0-9]+ exited on signal" /var/log/nginx/error.log
  • Unexpected child processes under an nginx worker (a shell, curl, wget):

ps -eo pid,ppid,user,cmd --forest | grep -A3 "nginx: worker"
  • Unusual outbound connections from the web server, new accounts or new SUID files.

  • An SCTP module loaded for no reason on a web server.

Which NGINX2Root CVEs apply to my server? (triage script)

This triage script runs read-only on a server. It does not trigger any vulnerability: it reads the version and the configuration, then shows which NGINX2Root CVEs apply.

#!/bin/sh
# Tri NGINX2Root en lecture seule. A lancer en root (nginx -T lit toute la configuration).
v=$(nginx -v 2>&1 | sed 's|.*nginx/||')
fixed=1.31.9; case "$v" in 1.30.*) fixed=1.30.7;; esac
if [ "$(printf '%s\n' "$fixed" "$v" | sort -V | head -1)" = "$fixed" ]; then
  echo "nginx $v : corrigé"
else
  echo "nginx $v : version amont vulnérable (vérifier le changelog si paquet de distribution)"
fi
conf=$(nginx -T 2>/dev/null)
echo "$conf" | grep -qE '^\s*http2\s+on|listen[^;]*\bhttp2\b' && echo "HTTP/2 actif : CVE-2026-123007, CVE-2026-123633"
echo "$conf" | grep -qE 'listen[^;]*\bquic\b' && echo "HTTP/3 actif : CVE-2026-121810"
echo "$conf" | grep -qE '^\s*mail\s*\{' && echo "Module mail : CVE-2026-113425"
echo "$conf" | grep -qE '^\s*resolver\s' && echo "$conf" | grep -qE '^\s*mirror\s' && echo "Resolver et mirror : CVE-2026-123634"
lsmod 2>/dev/null | grep -qw sctp && echo "Module SCTP chargé : étape root possible"

How does Patrowl detect NGINX2Root on your exposed assets?

On the day of publication, the Patrowl CERT added check #1892 to Trending Attacks, the section dedicated to ongoing attacks. It checked every nginx asset monitored in EASM and Pentested modes, without sending an exploit. Triggering the vulnerability in production could have crashed your servers: we did not do it.

For each asset, the check follows five steps:

  1. Identify the assets where nginx or OpenResty was detected: Server header, default error pages, technology detection.

  2. Open a TLS connection that offers HTTP/2 and HTTP/1.1, and record the protocol chosen by the server. On HTTP ports, check whether HTTP/2 is accepted without TLS.

  3. Confirm that nginx itself terminates HTTP/2, and not a CDN or a load balancer placed in front of it. The HTTP/2 settings sent by nginx have a signature of their own.

  4. Read the Alt-Svc header to see whether HTTP/3 is advertised, and the mail port banners to spot the nginx mail proxy.

  5. Compare the visible version with the fixed versions. An OpenResty version is mapped to the nginx version it is based on.

Each probe is a standard request, like the one a browser sends.

As of November 18, 2026, check #1892 is in "Potentially impacted" status for 127 customer teams, across 4,894 assets. This status means "to be checked", not "compromised".

Each affected customer also receives an Info-level vulnerability, "NGINX2Root: CVE-2026-123007 follow-up file of your assets", with an attached Excel file. The file ranks their assets and shows where to start:

CategoryWhat it meansAction
Vulnerable versionVisible vulnerable version. nginx answers HTTP/2 itself and advertises an affected version.Fix first. Update, or http2 off; in the meantime.
Shared hostingShared cPanel server. The server belongs to the hosting provider.Follow up with the hosting provider. The fix is in their hands.
To checkHidden version or distribution package. nginx answers with no version, or with a version that may include a backported fix.Check internally with nginx -v and the package changelog.
Behind a front-endA load balancer sits in front of nginx. The HTTP/2 connection most likely ends before nginx.Check whether nginx accepts HTTP/2 directly, then plan the update.

The guidance is the same for everyone: update nginx, disable HTTP/2 in the meantime if needed, block the SCTP module and follow up with the hosting provider for shared servers. The Patrowl CERT monitors the threat continuously, a method detailed in our article on proactive threat hunting with agentic AI. The same process was used for wp2shell in July 2026: the check was in place a few hours after the attack code was published.

What to watch in the coming days after NGINX2Root

  • Linux distributions release their fixed packages at their own pace. Until their advisory is out, the HTTP/2 workaround remains the available protection.

  • The Linux kernel fix for the SCTP vulnerability. Until then, blocking the module remains the defense.

  • The publication of an exploitation method simpler than Rapid7's, Wiz's for instance, would change the urgency. We are watching for it.

  • 1.30.7 and 1.31.9 arrive shortly after 1.30.6 and 1.31.7, which already fixed other nginx CVEs. A server still on an earlier version carries both series.

  • We are tracking a possible addition to the KEV catalog and will update this article and check #1892 accordingly.

  • The scenario echoes PHP2Shell: unauthenticated code execution in a component that almost every website uses.

FAQ

NGINX2Root: frequently asked questions

Why is the vulnerability called NGINX2Root?

The name, given by the Xint researchers, describes the attack path: from a simple visitor of the nginx server all the way to root privileges on the host. It groups five CVEs fixed on November 18, 2026, including CVE-2026-123007 in HTTP/2 flow control.

Is NGINX2Root easy to exploit?

No. The public attack sends about 128 GB over a single HTTP/2 connection and only works on certain x86-64 processors. Below about 300 Mbit/s, it fails. The more advanced methods from Wiz and Xint are not published. It grants the nginx worker’s privileges, not root. No exploitation in the wild has been reported. The update is still necessary, but without rushing.

Do I need to restart nginx after updating against NGINX2Root?

Yes. A reload rereads the configuration but keeps the old vulnerable binary in memory. After installing nginx 1.30.7, 1.31.9 or the fixed package, restart the service with systemctl restart nginx, then check the version with nginx -v.

Does disabling HTTP/2 against NGINX2Root break my site?

Not for a standard website: browsers fall back to HTTP/1.1 on their own. gRPC services, which need HTTP/2, do stop working. The http2 off; directive covers CVE-2026-123007 and CVE-2026-123633, not the other three NGINX2Root CVEs.

Do I need to update the Linux kernel against NGINX2Root?

Not possible yet: the SCTP vulnerability used to gain root has no fix to date. In the meantime, block the SCTP module from loading with the line install sctp /bin/false in /etc/modprobe.d/disable-sctp.conf. Most web servers do not use SCTP.

Is an nginx running in a Docker container protected from NGINX2Root?

No. The container shares the host kernel, and Xint reports obtaining root privileges on the host from a containerized nginx. Pull the fixed official image (nginx:stable at 1.30.7, nginx:mainline at 1.31.9), redeploy the containers and block the SCTP module on the host.

My site is behind a CDN: do I still need to fix NGINX2Root?

Yes, but the priority drops. A CDN that terminates the HTTP/2 connection very likely does not forward the attack frames to nginx. The protection only holds if the origin nginx server cannot be reached directly. Restrict access to it to the CDN’s address ranges, and plan the update.

My site is on shared hosting: what should I do about NGINX2Root?

Contact your hosting provider. On a shared server, such as a cPanel server, nginx belongs to the hosting provider and only they can install nginx 1.30.7 or 1.31.9. Ask them for the fix date and whether they have disabled HTTP/2 in the meantime.

Is NGINX2Root in the CISA KEV catalog?

No, as of November 18, 2026. No exploitation in the wild has been reported at that date. A proof of concept exists, but it requires lab conditions that are hard to reproduce. This article will be updated if the vulnerability is added to the KEV catalog or if exploitation is observed.

How does Patrowl check for NGINX2Root without risk to my servers?

Without sending an exploit. For each nginx asset monitored in EASM and Pentested modes, Patrowl checks whether HTTP/2 is active, whether nginx or a CDN is answering, and which version is advertised. Each probe is a standard request. Check #1892 then classifies each asset: Vulnerable version, Shared hosting, To check or Behind a front-end.