nginx2root is the name researchers at Xint gave to five nginx vulnerabilities fixed on 18 November 2026 in nginx 1.31.9 (mainline) and nginx 1.30.7 (stable). The worst of them lets an unauthenticated attacker run code on your server over HTTP/2, which nearly every HTTPS WordPress site on nginx has switched on. Chained with a separate Linux kernel bug, it goes all the way to root. This guide shows WordPress site owners how to check their nginx version and configuration, patch or mitigate, block the kernel route to root, and prove the fix is live.
Note: Every command output in this guide comes from our own tests: disposable, offline Docker containers built from the official
nginximages (1.30.6, 1.30.7, 1.31.8 and 1.31.9), plus one of our own Ubuntu servers for the kernel check. No exploit code was run.
What nginx2root is
nginx2root covers five memory-safety bugs in nginx. Xint reported them to F5, the company behind nginx, and published its write-up on the day the fixes shipped. Every release up to and including 1.31.8 is affected where the feature in question is in use. The fixed versions are 1.31.9 or later and 1.30.7 or later.
CVE
Bug
Needs
First affected
CVE-2026-123007
Memory corruption in HTTP/2 flow control
HTTP/2 enabled
1.9.5 (2015)
CVE-2026-123633
Use-after-free in HTTP/2
HTTP/2, with requests passed to an upstream while workers run low on worker_connections
1.19.7
CVE-2026-123634
Use-after-free in the resolver
resolver plus a proxy_pass host built from variables, with an SSI or mirror subrequest
1.13.4
CVE-2026-121810
Use-after-free in HTTP/3
HTTP/3 (QUIC), with requests passed to an upstream
1.25.0
CVE-2026-113425
Use-after-free in the mail proxy
Mail proxy with proxy on and auth_http
0.5.15
F5 scores CVE-2026-123007 at 9.2 Critical (CVSS 4.0) in the NVD entry. On nginx.org it and the mail proxy bug are rated "Major", and the other three "Medium". The same releases fix five further issues that are not part of nginx2root but are still worth having: an endless loop when reading request bodies over TLS 1.3 (CVE-2026-118899, also rated Major), a buffer overflow with alias and try_files (CVE-2026-125283), and three bugs in the stream module and PROXY protocol handling.
Official reference: nginx security advisories, the nginx 1.31.9 changelog and Xint's nginx2root write-up.
How an nginx bug becomes root
F5's own description of CVE-2026-123007 says the bug overflows a heap buffer and usually crashes the worker, and that attackers can execute code where ASLR (address space layout randomisation) is disabled or can be bypassed. According to The Hacker News, researchers at Wiz bypassed ASLR in their tests, and Xint needed nothing more than a reachable HTTP/2 port. So assume code execution is realistic. That code runs as the nginx worker process.
On their own, the nginx bugs stop there. Workers run as an unprivileged user such as www-data or nginx, so that is serious but not yet full control. On a WordPress server it can still be enough to read wp-config.php and its database password, or to plant files in a writable uploads folder.
The second half of the chain is a use-after-free in the Linux kernel's SCTP networking code, which Aikido says dates back to Linux 4.15. Xint used it to climb from the nginx worker to root on the host, and reports that this works from inside a Docker container too. When the research was published there was no CVE number and no kernel fix for this bug, which is why blocking SCTP matters (see below).
On release day, 18 November, nobody had reported attacks in the wild and CISA had not added the CVE to its Known Exploited Vulnerabilities catalogue. Proof-of-concept code is already public on GitHub, though its notes say it only demonstrates the attack against a freshly started Docker container on the same machine. With a public write-up and a ten-year-old bug in such a widely used feature, expect that picture to change quickly (source: The Hacker News report on nginx2root).
Which WordPress setups are affected
WordPress has no bug here; the flaws are in the web server in front of PHP. Updating plugins, themes or core does nothing for nginx2root.
-
HTTP/2 on HTTPS (most WordPress sites on nginx). A
listen 443 ssl http2;line orhttp2 on;exposes you to CVE-2026-123007. CVE-2026-123633 needs requests passed to an upstream as well. nginx sends PHP requests to PHP-FPM throughfastcgi_pass, which uses the same upstream machinery, so treat a standard WordPress server as in scope for both. -
Reverse proxies and asset proxies. A
resolverdirective combined with something likeproxy_pass http://$backend;brings in CVE-2026-123634. Plain WordPress configs rarely do this, but CDN proxies, multisite domain mapping and headless front ends sometimes do. -
HTTP/3 (QUIC). Only if you enabled
listen 443 quic;orhttp3 on;. - Mail proxy. Rare on WordPress servers, but some control panels set it up.
Your hosting type decides who does the work:
- Managed WordPress hosting: the host patches nginx. Your job is to get confirmation (see "Patch nginx" below).
- Server panels such as Laravel Forge: Forge warns that its automatic security updates do not update nginx, because nginx comes from a separate repository. Older Forge servers also used a PPA that has since been removed. Follow Forge's nginx2root guide, and check whether your own panel works the same way.
- Your own VPS or Docker stack: nobody else will patch it.
- Behind Cloudflare or another CDN: visitors speak HTTP/2 to the CDN, not to you. That only protects you if your origin accepts connections from the CDN alone. If the origin IP answers on 443 from anywhere, an attacker can go straight to nginx.
- Ubuntu 20.04 and older: according to Forge, nginx.org no longer builds packages for these releases, and the newest one available there (1.27.5) is still vulnerable. Ubuntu's own nginx package is fixed for 16.04, 18.04 and 20.04, but only through Ubuntu Pro, which is free for up to five machines. Either way, plan a move to a supported release.
Check your nginx version
Run this over SSH on the server, or inside the web container if you use Docker:
nginx -v
# Docker: docker exec <web-container> nginx -v
Output from the official images we tested, vulnerable first and patched second:
nginx version: nginx/1.31.8
nginx version: nginx/1.31.9
The package version and its maintainer tell you where nginx came from, which decides how you update it:
dpkg-query -W -f='${Version} ${Maintainer}\n' nginx # Debian and Ubuntu
rpm -q nginx # RHEL, AlmaLinux, Rocky
On the official images the package comes from nginx.org, and the version moves from 1.30.6-1~trixie to 1.30.7-1~trixie after the fix. If the maintainer line shows NGINX Packaging, you update from nginx.org. If it shows Ubuntu or Debian, your distribution's security team ships the fix.
To check many servers quickly, this script compares the running version with the fixed release for its branch. Save it as check-nginx.sh and run sh check-nginx.sh.
#!/bin/sh
# Compare the running nginx version with the nginx2root fixed releases
v=$(nginx -v 2>&1 | sed 's#.*nginx/##; s# .*##')
branch=$(echo "$v" | cut -d. -f1,2)
case "$branch" in
1.31) fixed=1.31.9 ;;
1.30) fixed=1.30.7 ;;
*) echo "nginx $v: branch $branch gets no fix - upgrade to 1.30.7 or 1.31.9"; exit 1 ;;
esac
if [ "$(printf '%s\n' "$fixed" "$v" | sort -V | head -n1)" = "$fixed" ]; then
echo "nginx $v: patched (needs $fixed or later)"
else
echo "nginx $v: VULNERABLE - upgrade to $fixed or later"; exit 1
fi
Against all four test images it gave the expected verdicts:
nginx 1.30.6: VULNERABLE - upgrade to 1.30.7 or later
nginx 1.30.7: patched (needs 1.30.7 or later)
nginx 1.31.8: VULNERABLE - upgrade to 1.31.9 or later
nginx 1.31.9: patched (needs 1.31.9 or later)
Warning: Distribution packages keep older version numbers and backport fixes. Aikido lists Ubuntu 24.04 (1.24.0), Ubuntu 22.04 (1.18.0), Debian 12 (1.22.1) and Debian 13 (1.26) as being in the affected range before any backport. On those builds the script will always report "branch gets no fix", so look up the CVEs in your distribution's security tracker and compare the full package version instead.
Ubuntu shipped fixes on 19 November in USN-9159-1, which covers all five nginx2root CVEs. You are patched once your nginx package is at least the version below (nginx-core, nginx-full and the other variants carry the same version):
Ubuntu release
Fixed package version
26.10
1.30.4-7ubuntu1.2
26.04 LTS
1.28.3-2ubuntu1.13
24.04 LTS
1.24.0-2ubuntu7.20
22.04 LTS
1.18.0-6ubuntu14.23
20.04 LTS
1.18.0-0ubuntu1.7+esm5 (Ubuntu Pro)
18.04 LTS
1.14.0-0ubuntu1.11+esm6 (Ubuntu Pro)
16.04 LTS
1.10.3-0ubuntu0.16.04.5+esm11 (Ubuntu Pro)
Debian was slower. On 19 November the Debian security tracker showed a fix only in unstable (sid, 1.30.6-4). Bookworm, trixie and forky were still listed as vulnerable. If you run Debian's own nginx package, apply the mitigations below now, and either switch to the nginx.org packages or watch the tracker for a security update.
Check which nginx2root features your config uses
First see which modules your binary has. The official images include all of them, on both vulnerable and fixed versions:
nginx -V 2>&1 | tr ' ' '\n' | grep -E '^--with-(http_v2|http_v3|mail|stream)'
--with-http_v2_module
--with-http_v3_module
--with-mail
--with-mail_ssl_module
--with-stream
--with-stream_realip_module
--with-stream_ssl_module
--with-stream_ssl_preread_module
A compiled-in module only matters if your configuration switches it on. nginx -T prints the full effective configuration, every include included, so search that for the directives each CVE needs:
sudo nginx -T 2>/dev/null | grep -nE \
-e '^\s*(http2|http3|resolver|mirror|auth_http|mail|stream)\b' \
-e '^\s*listen .*(http2|quic)' \
-e '^\s*(proxy_pass .*\$|fastcgi_pass|ssi on)'
We ran it on nginx 1.31.8 with a typical WordPress server block that also proxies one path to an asset host using a variable:
139: http2 on;
143: resolver 1.1.1.1 valid=300s;
150: fastcgi_pass 127.0.0.1:9000;
157: proxy_pass http://$backend;
Read it like this. Line 139 together with line 150 means the HTTP/2 bugs apply. Line 143 together with line 157 is the resolver pattern behind CVE-2026-123634. Any mail, auth_http or quic lines you did not expect deserve a closer look before you do anything else.
Configuration files can mislead, so also ask the server itself whether it accepts HTTP/2. If you sit behind a CDN, test the origin directly, because the CDN will always answer with HTTP/2:
echo | openssl s_client -connect ORIGIN_IP:443 \
-servername example.com -alpn h2 2>/dev/null | grep ALPN
We ran it against nginx 1.31.8 in an offline container, first with http2 on; and then with http2 off;:
--- http2 on
ALPN protocol: h2
--- http2 off
No ALPN negotiated
ALPN protocol: h2 means the server speaks HTTP/2 and is exposed to CVE-2026-123007 until it is patched.
Patch nginx
Back up the configuration first so that a package upgrade cannot cost you your server blocks:
sudo tar -czf /root/nginx-conf-$(date -u +%Y%m%d-%H%M).tgz /etc/nginx
Packages from nginx.org or your distribution
sudo apt-get update
sudo apt-get install --only-upgrade -o Dpkg::Options::=--force-confold nginx
sudo nginx -t && sudo systemctl restart nginx
--force-confold keeps your existing configuration files. On RHEL-family systems use sudo dnf upgrade nginx. If your nginx came from a PPA that no longer exists, switch to the official nginx.org repository first; Forge's guide above walks through it.
Warning:
systemctl reload nginxis not enough. A reload keeps the old binary in memory. Restart nginx so the patched binary is the one running.
Docker
Pin a fixed tag instead of relying on latest, then pull and recreate only the web container:
# docker-compose.yml: image: nginx:1.30.7 (or nginx:1.31.9 for mainline)
docker compose pull web
docker compose up -d web
docker exec <web-container> nginx -v
Remember images that bundle their own nginx, such as phpMyAdmin, control panels and all-in-one WordPress images, and Kubernetes ingress controllers. Aikido notes that ingress-nginx bundles nginx 1.27.1 and the project, archived in March 2026, will not ship a fix.
Managed and shared hosting
Open a ticket and ask directly: "Are your web servers patched for nginx2root (CVE-2026-123007 and related CVEs), running nginx 1.30.7 or 1.31.9 or a vendor build with the fixes, and restarted since?" Keep the answer.
Block the kernel route to root
Most WordPress servers never use SCTP, so the simplest defence against the second half of the chain is to stop the kernel loading it. First check whether it is loaded now:
lsmod | grep sctp
No output means it is not loaded. Then add a rule that refuses to load it in future, and test the rule with a dry run:
echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf
modprobe -n -v sctp
On our Ubuntu server (kernel 6.8) the dry run ends with install /bin/false, which confirms the rule wins:
insmod /lib/modules/6.8.0-149-generic/kernel/net/ipv4/udp_tunnel.ko.zst
insmod /lib/modules/6.8.0-149-generic/kernel/net/ipv6/ip6_udp_tunnel.ko.zst
install /bin/false
This rule does not unload a module that is already loaded, and it cannot help if SCTP is built into the kernel. If lsmod showed it, reboot after adding the rule. Docker containers share the host kernel, so do this on the host, not inside containers. Install the kernel update as soon as your distribution ships one, and reboot.
Mitigate if you cannot patch today
These steps cut exposure while you wait; none of them replaces the upgrade. Change one thing at a time and run sudo nginx -t before each restart.
-
Turn off HTTP/2. On nginx 1.25.1 or later set
http2 off;in each server block; on older versions removehttp2from thelistenline. This blocks CVE-2026-123007 and CVE-2026-123633. The site falls back to HTTP/1.1 and keeps working. Restart nginx and run theopenssl s_clientcheck again; it should now sayNo ALPN negotiated. -
Turn off HTTP/3. Remove
quiclisteners, sethttp3 off;, remove anyAlt-Svcheader that advertises HTTP/3, and optionally block UDP port 443. -
Avoid DNS lookups at request time. Point
proxy_passat a fixedupstreamblock instead of a variable, and turn offmirrorwhere you do not need it. Xint notes that other subrequest features such as SSI may still reach the bug, so this is a partial fix only. -
Close the mail proxy. Bind it to
127.0.0.1or firewall it to trusted IPs. - Lock the origin to your CDN so that only its published IP ranges can reach ports 80 and 443.
- Restart, do not just reload, so that old workers holding existing connections are replaced.
Verify the fix and look for signs of trouble
1. The binary is fixed. Run the check script again and look for "patched", or check the package version against your distribution's advisory.
2. The running process uses it. If nginx was not restarted, the old binary is still running from memory and Linux marks its file as deleted:
sudo ls -l /proc/$(cat /run/nginx.pid)/exe
If the result ends in (deleted), run sudo systemctl restart nginx and check again.
3. The configuration loads. A successful test looks like this:
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
Warnings that listen ... http2 is deprecated are harmless.
4. WordPress still works. From another machine, check the protocol and the login page, then log in, save a draft and submit a test comment:
curl -sI --http2 https://example.com/ | head -n1
curl -s -o /dev/null -w '%{http_code}\n' https://example.com/wp-login.php
5. Nothing odd is running as the web server user. nginx workers never start other programs, so any child process under a worker is a red flag:
ps -eo user,pid,ppid,lstart,cmd --forest | grep -A3 'nginx: worker'
6. Logs are quiet. Xint suggests looking for workers exiting abnormally, long-lived connections from one address that send a lot and receive little, and bursts of short TLS connections from the same IP. The error log is the easiest place to start:
sudo grep -E 'exited on signal|signal (6|11)' /var/log/nginx/error.log* | tail -n 20
Xint warns that these attacks may leave little trace in normal access logs, so a clean result is reassuring but not proof. If you find anything suspicious, rotate the database password and WordPress salts, and check for unknown admin users and new PHP files in wp-content/uploads.
Keep WordPress servers ahead of the next one
- Watch the nginx.org news page and your distribution's security announcements, so you hear about a fixed release on the day it ships.
- Keep a list of every server, container and image that runs nginx, including staging sites, phpMyAdmin and ingress controllers.
- Pin Docker images to exact versions so you always know what is deployed.
- Treat PHP the same way. Our guide to the PHP2Shell critical RCE uses the same check, patch and verify routine for the PHP interpreter.
- Add a WordPress-level layer too. A server patch stops attacks on nginx; a good plugin from our list of the best WordPress security plugins watches logins, file changes and suspicious requests inside WordPress.
The short version: run nginx -v today, get to 1.30.7 or 1.31.9 (or your distribution's fixed package), restart nginx so the new binary is the one running, block SCTP on the host, and test your login and checkout pages afterwards.
Further reading: nginx2root.com and Aikido's nginx2root analysis.
Originally published on WP Tuts Hub.
Top comments (0)