
Get security briefings from the Threat Research Team
New campaigns, attacker techniques, and detection guidance — straight to your inbox.
Falco Feeds extends the power of Falco by giving open source-focused companies access to expert-written rules that are continuously updated as new threats are discovered.

On November 18, 2026, F5 published CVE records for five memory-safety bugs in NGINX, and the project shipped fixes the same day in NGINX 1.31.9 (mainline) and 1.30.7 (stable). Each bug allows an unauthenticated remote attacker to corrupt memory in an NGINX worker process, and all five carry a CVSS 4.0 score of 9.2.
Xint, one of the teams that reported the bugs, published a write-up dubbing the set of vulnerabilities “NGINX2Root.” Xint also chained one of the NGINX bugs with a previously unknown Linux kernel bug in the Stream Control Transmission Protocol (SCTP) to get root on the host, including from inside a Docker container running the official NGINX image.
At the time of publication for this blog, there has been no public proof-of-concept (PoC) or reported in-the-wild exploitation. However, several teams found the HTTP/2 bugs independently, and both Xint and Wiz researchers say they’ve built working exploits that bypass address space layout randomization (ASLR). Also, the Linux kernel bug has not yet been assigned a CVE, nor has a fix been released.
The Sysdig Threat Research Team (TRT) reviewed the disclosures and tested post-exploitation activity in a lab to help defenders understand who is exposed, what they can do before a fixed package reaches every host, and what runtime detection can see. This blog covers the five NGINX bugs, the kernel half of the chain, and what defenders can do now.
Timeline
All dates are in UTC.
The vulnerabilities and affected NGINX versions
All five CVE records have been assigned the same scores: 8.1 (High) on CVSS 3.1 and 9.2 (Critical) on CVSS 4.0. NGINX2Root is network-based, doesn’t require authentication, and is relatively complex. F5 describes the impact as a worker crash or memory corruption, with code execution where ASLR is disabled or can be bypassed. All five are data-plane bugs, and F5 states there is no control-plane exposure.
The fixed releases are NGINX 1.31.9 and 1.30.7. For NGINX Plus, they are 37.3.0.1 and 37.0.8.1 (37.2.0.1 and 37.0.7.1 fix CVE-2026-123633). The same release fixes five more NGINX CVEs, including CVE-2026-118899, an infinite loop while reading a client request body over TLS 1.3, which NGINX rates as major. Upgrading to these versions fixes all 10 bugs.
Any NGINX version before 1.31.9 (mainline) or 1.30.7 (stable) is vulnerable if it has one of the features in the vulnerability table above enabled. How you check depends on where your NGINX comes from. There are four factors to consider for exposure:
- Distribution packages: Distribution packages keep their version string when they backport a fix, so
nginx -vwon’t tell you whether you're patched. Ubuntu 24.04 ships NGINX 1.24.0, Ubuntu 22.04 ships 1.18.0, Debian 12 ships 1.22.1 and Debian 13 ships 1.26.3. Fixes for these will arrive as new package revisions. For example, Xint notes that Ubuntu 22.04's package went from1.18.0-6ubuntu14to1.18.0-6ubuntu14.22while still reporting 1.18.0. As of November 18, Debian and Ubuntu list every supported release as vulnerable to CVE-2026-123007, with no fixed package yet. NGINX.org packages, official images, and source builds report the upstream version, songinx -vwill provide an accurate patch status. The officialnginx:1.31.9image is available. - Container images: Images are only fixed when they are rebuilt on a fixed NGINX and redeployed. A running container doesn't change when the host is patched. Patch and redeploy.
- Kubernetes ingress-nginx: The project was archived on March 24, 2026. Its README says there will be "no further releases, no bugfixes, and no updates to resolve any security vulnerabilities." The controller image includes its own NGINX build, so the project will not ship these fixes.
- NGINX-derived software: Software built on NGINX's code, such as OpenResty, Tengine and Angie, is not named in the advisories. Check with those maintainers for possible exposure.
For scale, Xint counted 56.7 million hosts in Shodan identified as NGINX on November 10, 2026. Of the 11.94 million hosts that reported a version, 98.9% fell inside the 1.9.5 – 1.31.8 range vulnerable to CVE-2026-123007. Because of backports and feature requirements, a version banner doesn't prove a host is vulnerable. However, it does show how few public servers are on a current release.
Why teams should prioritize CVE-2026-123007
This is the bug with the widest reach. It needs only HTTP/2, which is a common setting on public HTTPS servers. Researchers have reported that serving ordinary static files is enough to reach the vulnerable code: No backend application or third-party module is needed. They have also confirmed RCE with an ASLR bypass on official NGINX 1.31.7 and 1.31.8 builds, over HTTP/2 with TLS on 64-bit systems. For example, Xint ran its exploit against a public HTTPS endpoint on AWS. The flaw itself dates back to NGINX 1.9.5, the release that added HTTP/2 support.
F5 credits four independent reporters for this CVE, and researchers describe exploitation as difficult. However, when four teams find the same bug independently, regardless of how challenging exploitation is, it is reasonable for defenders to assume that they’re not the only ones looking.
Understanding the other four NGINX2Root CVEs
Each of the other bugs requires a specific feature to be turned on, which narrows the potential list of exposed users:
- CVE-2026-123633 also needs HTTP/2, plus proxying to an upstream. Turning off HTTP/2 blocks both HTTP/2 bugs.
- CVE-2026-123634 needs a
proxy_passdestination built from request variables, aresolver, and a subrequest frommirroror SSI. Researchers note that turning offmirroralone is not enough, because SSI also creates subrequests. Settingmirror_request_bodyon does not fix it either. - CVE-2026-121810 affects only servers with HTTP/3 enabled.
- CVE-2026-113425 affects only servers that run the NGINX mail proxy with
auth_http.
SCTP and the Linux kernel bug
The "to root" part of NGINX2Root is a separate bug. Researchers found a use-after-free and double-free in the Linux kernel's SCTP code, introduced by Linux 4.15 in 2018. According to Xint, it leaks kernel memory to defeat kernel ASLR and lets an attacker call an arbitrary kernel function. This bug currently has no CVE or patch, and researchers are withholding further details until a fix exists.
It’s important to note that hosts that never use SCTP are exposed, too. On most distributions, the sctp kernel module is not loaded until a process opens an SCTP socket, and then the kernel loads it automatically. So an attacker running code as an unprivileged NGINX worker can load the vulnerable code into the kernel themselves. In the Sysdig TRT lab, a single SCTP socket opened from the NGINX worker was enough to load sctp.ko. Once loaded, the module stays loaded until the next reboot.
Containers don't change this, because they share the host's kernel. Researchers ran the chain from inside a Docker container built from the official nginx:1.31.8 image and got root on the underlying host.
Blocking the module closes this path on hosts that don't need SCTP. With install sctp /bin/false in a file under /etc/modprobe.d/, the NGINX worker's SCTP socket call failed with EPROTONOSUPPORT in the Sysdig TRT lab, and the module was not loaded.
The block has three limits, however: It doesn't unload a module that is already loaded, it doesn't help where SCTP is compiled into the kernel, and it breaks workloads that use SCTP, such as telecom signaling and some Kubernetes network plugins.
The impact of NGINX2Root
- Worker crashes and memory corruption: F5 describes the impact as a worker crash or memory corruption. An attacker can send crafted traffic to an exposed NGINX server without credentials.
- Code execution as the NGINX worker: Researchers report working exploits that bypass ASLR. Normally, code execution in an NGINX worker is limited to the worker's unprivileged user.
- Root on the host and container escape: The SCTP kernel bug turns a worker compromise into root on the host, including from inside a Docker container, because containers share the host's kernel.
- A patch gap: The fix is released, but most fleets haven't received it yet. Most NGINX in production comes from a distribution package or a container base image. For those, the fix arrives when the distribution ships a backport and the image is rebuilt. Expect a gap of days or more between the upstream release and the build you actually run.
What this means for defenders
- The fix is released, but most fleets haven't received it yet. Most NGINX in production comes from a distribution package or a container base image. For those, the fix arrives when the distribution ships a backport and the image is rebuilt. Expect a gap of days or more between the upstream release and the build you actually run.
- The configuration workarounds are narrow and effective. Turning off HTTP/2 blocks the two most reachable bugs, including CVE-2026-123007. The other three need features that many deployments don't use. Find out which features your servers actually have enabled, so you know how much exposure you have before a fixed package arrives.
- The kernel bug makes a worker compromise much worse. Normally, code execution in an NGINX worker is limited to the worker's unprivileged user. The SCTP bug turns that into root on the host, and an escape from the container. Blocking the
sctpmodule costs nothing on hosts that don't use it. Today, this is the only mitigation for the kernel half of the chain. - Reloading isn't enough. A configuration reload leaves existing connections on the old worker processes. After you upgrade or change the configuration, restart NGINX, or confirm that every old worker has exited.
How to detect NGINX2Root
No public exploit code has been released and there is no reported in-the-wild exploitation, so the attack itself can't yet be replayed. Instead, the Sysdig TRT ran post-exploitation payloads from inside a real, vulnerable NGINX 1.31.8 worker process, in a container and on the host, which are the steps an attacker would take after gaining code execution.
However, researchers have confirmed RCE with an ASLR bypass, ran an exploit against a public HTTPS endpoint on AWS, and chained an NGINX bug with the SCTP kernel bug to get root on the host. These exploits have been described as difficult, but they are possible. Four teams found the CVE-2026-123007 vulnerability independently, so defenders should assume threat actors are working on it as well.
Threat intelligence
Sysdig Secure customers can use the Sysdig Threat Intelligence feed to find hosts and workloads that run an affected NGINX version, including NGINX bundled in other software. The feed checks versions, not enabled features. A host fixed by a distribution backport can stay listed until the feed is updated.
Runtime detection
Sysdig Secure customers can also detect attacker activity at each of these stages:
- A shell started by the NGINX worker: Run shell untrusted.
- A reverse shell from the worker: Reverse Shell Detected, and Redirect STDOUT/STDIN to Network Connection in Container.
- A second-stage binary dropped and run: Drop and execute new binary in container, and Execution from
/tmp.
Ordinary NGINX activity did not trigger any of these rules in our testing. This includes plain requests, HTTP/2 load, proxying, resolver and mirror traffic, configuration reloads, and the fixed NGINX 1.31.9 image.
Security teams should expect some alerts on patch day, because legitimate maintenance can resemble post-exploitation activity in some cases. For example, when we upgraded NGINX in place with its live binary upgrade (rather than a restart) in our lab, this triggered Sysdig Secure’s Non sudo setuid and Container Run as Root User rules. A configuration reload didn’t trigger these rules. If you upgrade this way, you’ll likely see similar alerts from your runtime detection tool. Scope any tuning to the maintenance window instead of suppressing the rules permanently to reduce the noise.
Researchers also suggest watching for these signs, though they note that these are general warning signs to be weighed together, and not confirmed indicators of vulnerability exploitation:
- NGINX worker crashes and segmentation faults in
error.logorcoredumpctl. - Commands run by the NGINX worker's user.
- Long-lived HTTP/2 connections that receive a large amount of data and send back very little.
Detecting NGINX2Root with open source Falco
Falco sees syscalls, not HTTP requests. It can't see the malicious request itself, but it can see what the request causes on the host. Use the Falco open source ruleset to detect post-exploitation activity such as a shell or a new binary started by an NGINX worker.
Recommendations
Patch
- Upgrade to NGINX 1.31.9 or 1.30.7, or NGINX Plus 37.3.0.1 or 37.0.8.1. Then, restart NGINX rather than reloading it, and confirm that every old worker process has exited.
- Follow your distribution's advisory, not the upstream version number. Install the fixed package revision when it ships.
- Rebuild and redeploy container images that include NGINX once a fixed base image is available.
- Plan a migration off ingress-nginx. The project will not ship these fixes.
Temporary mitigation if you can’t patch right away
- Disable HTTP/2 until you're patched. On NGINX 1.25.1 and later, set
http2 off;in each affectedserverblock and removehttp2fromlisten. On 1.9.5 through 1.25.0, removehttp2fromlisten. Turn it back on after upgrading. - Remove request-time DNS lookups. Point
proxy_passat a fixedupstreamgroup rather than a variable, and turn offmirrorand SSI where you don't need them. - Disable HTTP/3. Remove
quiclisteners, sethttp3 off;, sendAlt-Svc 'clear', and block UDP on the port.
Contain the blast radius, investigate, and audit
- Block the SCTP module on hosts and Kubernetes nodes that don't use SCTP: add
install sctp /bin/falseto a.conffile in/etc/modprobe.d/. Runlsmod | grep sctpto check whether it's already loaded. If it is and nothing on the host uses it, the block takes effect after the next reboot. - Restrict the mail proxy. Bind the IMAP, POP3, and SMTP listeners to loopback, or allow only trusted sources through the firewall.
- Watch for NGINX worker crashes and for processes started by NGINX workers.
Conclusion
NGINX2Root combines five NGINX bugs that already have a fix with one Linux kernel bug that doesn't.
The NGINX half is a patch-management problem: The upstream fix is out, but distribution packages and container images will take time to catch up, and the configuration workarounds can cover that gap. The kernel half requires immediate attention, and turns the compromise of an unprivileged worker into root on the host.
Although no public exploit has been released as of this blog’s publication, researchers already claim to have working POCs. The time for teams to patch is now.
