Key Takeaways
- NGINX2Root exposed five memory-corruption vulnerabilities in NGINX, including an HTTP/2 integer underflow that had been present since 2015.
- AI-assisted analysis helped researchers uncover NGINX memory bugs that had gone undetected for years.
- RunSafe’s engineering team determined that RunSafe Protect can prevent attackers from exploiting all five NGINX vulnerabilities and the separate Linux kernel flaw. Load-time Function Randomization disrupts the exploit chain so an attack cannot succeed.
On November 18, 2026, multiple security research teams disclosed a series of critical vulnerabilities in NGINX, one of the world’s most widely used web servers. The flaws, collectively known as NGINX2Root, affect software that sits at the front of millions of websites and applications.
One of the vulnerabilities, a type of memory vulnerability known as an integer underflow, dates back to 2015, meaning it went undetected for more than a decade. Now, researchers have demonstrated how it can be exploited to remotely execute code on a server, bypass existing memory protections, and, when combined with another vulnerability, gain root access.
The discoveries follow October’s PHP2Shell vulnerabilities, another set of critical memory-safety vulnerabilities in widely deployed software.
Both NGINX2Root and PHP2Shell are examples of how vulnerabilities that once required significant expertise and time to uncover are becoming easier to find with AI-assisted vulnerability research.
And as discovery accelerates, organizations have less time to find affected systems, test patches, and deploy fixes before working exploits become available.
What Happened with NGINX2Root?
Researchers from Wiz, Xint, Rapid7, and other teams independently discovered critical memory-corruption vulnerabilities in NGINX.
Two of the most notable flaws are:
- CVE-2026-123007: An integer underflow in HTTP/2 flow control that can cause a heap buffer overflow. It affects NGINX versions dating back to 2015 and can be triggered on vulnerable servers with HTTP/2 enabled.
- CVE-2026-123633: A use-after-free vulnerability that can occur when NGINX improperly frees memory associated with an active HTTP/2 connection during reverse-proxy processing.
The disclosure also includes three additional use-after-free vulnerabilities affecting NGINX’s HTTP/3 handling (CVE-2026-121810), DNS resolver processing (CVE-2026-123634), and mail proxy functionality (CVE-2026-113425).
Each of these five vulnerabilities can enable unauthenticated remote code execution under its respective affected configuration.
Because NGINX frequently acts as a reverse proxy, handling incoming requests for multiple websites, services, and APIs, a vulnerability in that shared infrastructure can expose several applications even when their individual code is secure.
Researchers at Xint demonstrated how CVE-2026-123007 could be exploited to execute commands with NGINX worker privileges. They then chained it with a separate memory-safety vulnerability in the Linux kernel’s Stream Control Transmission Protocol (SCTP) subsystem to gain root access to the underlying host, including escaping from a Docker container.
The kernel vulnerability involves use-after-free and double-free conditions and dates back to Linux 4.15 in 2018.
What we see with the resulting attack is that multiple memory vulnerabilities, each present in widely deployed software for years, can be combined to compromise an entire system.
AI Is Changing How Quickly Memory Bugs Are Found
Perhaps the most consequential part of the NGINX2Root discovery is how the vulnerabilities were found.
According to Xint’s research, a researcher initially identified CVE-2026-123007, and an automated scan subsequently discovered four additional vulnerabilities without human guidance.
Wiz also reported using AI-powered code analysis to identify its findings and AI models to help validate their impact.
Historically, memory corruption vulnerabilities have been difficult for security researchers to find because they depend on subtle interactions among memory operations, program state, and execution paths. Once, it may not have been worth the effort to look for these types of bugs.
But the barrier to discovering these vulnerabilities is falling as AI-assisted analysis advances. AI makes speed and scale a commodity for legitimate security researchers as well as attackers.
RunSafe Protect Addresses All Six NGINX2Root Memory Vulnerabilities
RunSafe has spent years addressing the memory safety problem in code through RunSafe Protect.
Protect uses Load-time Function Randomization (LFR) to change the locations of individual functions within protected software each time it loads. This disrupts code-reuse attacks that depend on knowing where particular functions or instruction sequences reside in memory.
The goal is to prevent an attacker from exploiting a memory vulnerability to achieve successful code execution, even before the underlying software bug is patched.
RunSafe’s engineering team has reviewed the NGINX2Root findings and determined that Protect can cover all five disclosed NGINX memory vulnerabilities, as well as the separate Linux kernel vulnerability used in the root escalation chain.
That includes:
- NGINX remote code execution: The five vulnerabilities affecting HTTP/2, HTTP/3, DNS resolver processing, and mail proxy functionality.
- Linux kernel privilege escalation: The separate SCTP memory-corruption vulnerability that researchers exploited to move from NGINX worker privileges to root access on the underlying host.
The demonstrated attack has two stages. First, an attacker exploits NGINX to gain code execution. Then, a separate kernel vulnerability allows the attacker to escalate privileges and compromise the host.
Protect can provide memory exploit mitigation at both stages when applied to the relevant software and kernel components.
What We Already Demonstrated with PHP2Shell
We recently demonstrated the effectiveness of this approach against another widespread memory vulnerability: PHP2Shell.
In October, RunSafe’s engineering team recreated a PHP2Shell use-after-free vulnerability and developed a working exploit.
The results were straightforward:
- Without RunSafe Protect: The exploit succeeded in all 10 tests.
- With RunSafe Protect: The same exploit failed in all 10 tests.
The PHP vulnerability was still present, but the exploit could no longer find the instructions it depended on at their expected memory addresses.
You can read the full technical breakdown in PHP2Shell: What Happened When We Added Runtime Protection.
The broader benefit of runtime exploit prevention is that it addresses attack techniques shared across multiple vulnerabilities. Organizations can deploy protection against classes of memory exploitation rather than waiting for each individual bug to be discovered.
Why ASLR Isn’t Enough
NGINX2Root also demonstrates the limits of a memory protection mechanism that has been widely used for decades: Address Space Layout Randomization (ASLR).
ASLR makes memory exploitation more difficult by changing where programs and libraries are loaded in memory. Attackers attempting to redirect program execution cannot simply assume those components will be located at predictable addresses.
However, ASLR typically moves entire executable images or libraries while preserving the relative positions of functions within them.
If attackers can disclose a memory address, they may be able to calculate where other useful code resides.
That’s exactly what researchers demonstrated with NGINX2Root.
Both Wiz and Rapid7 described exploitation techniques that use memory disclosure to recover addresses that ASLR is intended to conceal. Those addresses can then help attackers redirect execution to existing code.
ASLR remains a valuable security measure, but the demonstrated exploits show that it cannot reliably prevent code execution once an attacker gains sufficient visibility into the process’s memory.
Preventing memory-corruption exploits requires stronger protection of the software’s execution paths, even when attackers discover a vulnerability and attempt to bypass ASLR.
The Next Vulnerability Is Already in the Code
NGINX2Root and PHP2Shell are reminders that widely used, actively maintained software can contain serious vulnerabilities for years before anyone discovers them.
As AI-assisted vulnerability research advances, organizations should expect more of these longstanding bugs to surface.
Developers and security teams still need to identify vulnerable systems and deploy patches. For NGINX2Root, that means updating affected installations to patched releases, including NGINX Open Source 1.30.7 or 1.31.9, and applying temporary mitigations where appropriate. Organizations must also assess the separate Linux kernel vulnerability and the mitigations relevant to their environments.
But patching is a reactive process. It starts after a vulnerability has been identified, and it takes time to reach every affected system. In long-lived embedded devices, industrial environments, and other operational systems, updates may require extensive testing, maintenance windows, or supplier coordination.
Runtime exploit prevention helps close that gap.
When software is protected against the techniques attackers use to exploit memory corruption, a newly discovered vulnerability does not automatically provide a reliable path to code execution. That protection can remain in place across future vulnerabilities, including ones that have not yet been disclosed.
The opportunity is to reduce the exploitability of an entire class of vulnerabilities, rather than repeatedly racing to patch each new CVE.




