No Login Needed: Two NGINX HTTP/2 Flaws Let Attackers Run Code — One Hid in the Code Since 2015
On 18 November 2026 Wiz and F5 disclosed two NGINX HTTP/2 remote code execution flaws, both CVSS 4.0 9.2. One hid in the code for over 11 years, and five independent teams found them at once. Fixed releases are out — upgrade, or turn HTTP/2 off meanwhile.

One sentence: no login, no bug in your website — NGINX itself can be taken over
On 18 November 2026, security company Wiz and F5 jointly disclosed two severe vulnerabilities in NGINX, tracked as CVE-2026-123633 and CVE-2026-123007, each scoring 9.2 on the CVSS 4.0 scale and rated Critical. What makes them alarming is what they do not require: no account, no login, and no flaw in your own website's code. If your NGINX has HTTP/2 enabled, an attacker may be able to execute arbitrary code directly on the server. As Wiz puts it, the flaws are in NGINX itself, so websites and APIs can be exposed even when their own application code is secure. A single NGINX deployment often serves several websites and APIs at once, so one compromised instance can put more than one service at risk.
What deserves equal attention is how old these bugs are. The one tracked as 123007 had been hiding in the code for more than eleven years, traceable to NGINX 1.9.5, released in 2015; the one tracked as 123633 had been there for nearly six years, since 1.19.7 in February 2021. These are not bugs written last week. They are cracks in old code that the whole world has been running for over a decade without noticing. This time, five independent research teams ran into them at roughly the same moment: Wiz Research, Ikotas Labs, Metnir, Rapid7, and Xint. Wiz says its Atlas scanning harness surfaced both vulnerabilities, and its researchers then used Gemini 4 Carbon and ChatGPT 5.6 Sol to validate that each could be turned into unauthenticated remote code execution. That fact is itself the news: AI is dismantling the old defense that says "hidden deep enough means safe enough."
Two flaws: one broad, one narrow
Start by telling the two vulnerabilities apart. Both travel over HTTP/2, but their trigger conditions and blast radius are different. CVE-2026-123007 is the broad one: an integer underflow in HTTP/2 flow control. Wiz's table describes it as "exploitable in default configurations with HTTP/2 enabled," affecting versions from 1.9.5 all the way to 1.31.8. In testing, Wiz demonstrated code execution on NGINX serving ordinary static files, with no backend application and no third-party modules. That means even a server that only hosts static pages is in range. When you triage, you cannot look only at reverse proxies and API gateways; static sites have to be on the list too.
CVE-2026-123633 is the narrower one: a use-after-free in HTTP/2 connection handling, reachable only when NGINX is configured as a reverse proxy and the worker is running low on available connection slots, affecting versions 1.19.7 through 1.31.8. Narrow conditions do not mean small harm: once triggered, it is the same unauthenticated remote code execution. And in practice NGINX most commonly sits exactly in that reverse-proxy role, taking traffic in front and forwarding it to a stack of application servers, where connection slots running tight at peak hours is nothing unusual. So the two flaws should be read together: one covers a wide surface, the other targets the most common deployment shape.
One more fact sets the priority for this incident: both vulnerabilities require the target server to have HTTP/2 enabled. NGINX does not turn HTTP/2 on by itself, so exposure comes from an explicit configuration choice. But today HTTP/2 is standard on mainstream websites, and enabling it is close to a default deployment step. So "requires HTTP/2" is a real qualifier on paper and a weak shield in practice. The first triage step follows directly: find out which NGINX instances accept HTTP/2 connections from clients. Checking only the protocol NGINX uses to reach its backends is not enough; the client-facing exposure is what matters.
How eleven-year-old code got dug up
The disclosure timeline is worth reading closely, because it shows how fast modern vulnerability discovery has become. On 21 October 2026, Wiz reported the use-after-free vulnerability to F5, including confirmed remote code execution with an ASLR bypass and a proposed fix; F5 confirmed that another research team had previously reported the same vulnerability. On 10 November, F5 supplied a patch for CVE-2026-123633 for review. On 16 November, Wiz reported the second vulnerability, the integer underflow. On 17 November, F5 confirmed that the second report matched CVE-2026-123007 and was included in the planned 18 November security release. On 18 November, F5 shipped the security release and both sides disclosed together. From the first report to disclosure took less than a month; the second flaw went from report to disclosure in two days.
That speed was unimaginable not long ago. Wiz states it plainly in the blog post: these memory-safety flaws have historically been extremely difficult to discover and exploit, because finding them often requires tracing subtle interactions between memory operations and multiple code paths, and for years that complexity itself created a practical barrier. AI is fundamentally dissolving that barrier. As models get better at following those interactions, both researchers and attackers can uncover longstanding flaws in software that powers the internet. That several independent teams hit the same vulnerabilities in the same window, after they had remained in the code for years, is, in Wiz's view, evidence that the shift has already happened: complexity can no longer be relied upon as a barrier to discovery or exploitation.
This is not an isolated event. In the same post, Wiz notes that the PHP2Shell vulnerabilities it reported last month follow the same pattern; and just one day before this disclosure, on 17 November, another high-severity OpenJDK flaw known as Java4Shell was made public. Within a single month, PHP, Java, and NGINX — three pieces of internet infrastructure — each produced a long-hidden memory-safety problem. That rhythm is itself the judgement: more of these "old debts in old code" are coming, and the window defenders get between disclosure and exploitation will only get shorter.
How the attacks actually work: two plain-language explanations
First, CVE-2026-123633, the use-after-free. NGINX keeps a list of connections it can close when it needs room for new ones: an HTTP/2 connection with no active requests joins this reusable list, and leaves it when a request starts. The bug is that, under a specific timing, a connection is wrongly left on the list. The attacker first sends only part of a HEADERS frame — the frame that carries an HTTP/2 request's headers. With no active request stream, NGINX marks the connection as reusable while waiting for the rest. When the attacker sends the rest of the frame, a request stream is created and the connection now has a request in progress, but it is never removed from the reusable list. The result is a connection actively processing a request that NGINX still treats as safe to close at any time.
Next, the attacker makes NGINX connect to an upstream application server. Opening an upstream connection can trigger a cleanup when free connection slots run low, and NGINX picks connections from the reusable list to close — including the one still processing its own request. Before closing it, NGINX tries to send a GOAWAY frame to notify the client, but if that step fails too, for example because the connection has hit its internal frame limit, the error path closes the connection and frees its memory outright. The original request keeps running, still using that freed memory. That is the use-after-free. The freed memory can then be reused for other data, while the request-processing code keeps following its old pointers, treating the new contents as the original request or connection — and that can be steered toward executing attacker-controlled code.
Now CVE-2026-123007, the integer underflow. HTTP/2 lets several requests, called streams, share one connection, and flow control limits how much response data NGINX can send before the client is ready to receive more. NGINX tracks the connection's remaining allowance in a counter called send_window: it subtracts the size of queued response data before sending it, and if a stream is canceled while its data is still queued, a cleanup function removes the unsent data and returns the unused allowance. The problem is that this refund does not check HTTP/2's maximum allowed window. If the client has already increased the allowance while data was waiting to be sent, the refund can push the counter above that maximum. NGINX is now tracking a value the rest of its HTTP/2 code assumes cannot occur.
The next check then fails. Another function tests whether an increase would exceed the limit by subtracting the current allowance from the maximum to see how much room remains. But the allowance has already been pushed past the maximum, and because the calculation uses an unsigned integer, which cannot represent a negative number, the subtraction wraps around and underflows to a very large positive value. The check now treats an invalid counter as though it has plenty of room left, and allows further increases. The polluted counter eventually reaches the function that sends data, where it is converted to the signed integer type off_t to calculate how much data to send. A sufficiently large value becomes negative, and that negative length reaches the code describing a portion of a response buffer, leaving its end pointer before its start pointer. In the TLS send path, further signed and unsigned conversions turn the invalid length into an out-of-bounds memory copy. An attacker can use this to disclose memory, corrupt the heap, and achieve unauthenticated remote code execution on the NGINX server. Wiz says it confirmed remote code execution with an ASLR bypass on official NGINX 1.31.7 and 1.31.8 builds, using HTTP/2 over TLS on 64-bit systems serving response data from memory, and that ordinary static files can reach this path through standard TLS processing, without a backend application or third-party module.
What 9.2 really means — and what it does not
A CVSS 4.0 score of 9.2, rated Critical, needs to be read correctly. It measures how severe the flaw is once its conditions are met: unauthenticated, remotely triggerable, able to execute arbitrary code on the server. Wiz states explicitly that typical memory-safety mitigations such as ASLR do not protect against these issues, because attackers can use either vulnerability for memory read access before code execution. But 9.2 does not mean "trivially exploitable." Wiz is equally explicit about the difficulty: these flaws are hard to exploit remotely, requiring the attacker to disclose memory addresses, groom and shape the heap correctly, and handle different NGINX versions, builds, and configurations. In practice, attacks are more likely to start against packaged products where many customers use the exact same build and configuration — as Wiz observed with PHP2Shell, where widespread attacks initially targeted packaged products. Motivated attackers may then tailor exploits for specific targets.
Another number that needs a cool head is 225 million. Netcraft's September 2026 web server survey counted more than 225 million sites using NGINX, a figure Wiz also cites. But that measures how widely the software is used, not how many servers are vulnerable. Real exposure depends on the installed version, whether HTTP/2 is enabled, and how the server is configured. Multiple sites can also share a single NGINX deployment, so a site count is not a count of affected servers. Reading 225 million as "225 million servers can be broken into" would be wrong. The other direction matters too: precisely because NGINX is the world's most widely used open-source web server, a core flaw in it has a naturally large blast radius, and triage cannot stop at your own few machines — it has to consider how many services sit behind each one.
There is also no reported evidence of exploitation in the wild so far. Wiz says it built proof-of-concept exploits to confirm the vulnerabilities and ran them in multiple lab settings against servers running common NGINX configurations seen in customer environments, but will not release the exploits at this time in the interest of customer protection. Independent cross-coverage confirms the same boundary: the disclosures establish that remote code execution is possible under the reported conditions, but do not on their own establish that attackers have used either flaw against production systems. That distinction matters: it makes this an urgent patching event, not an ongoing intrusion. But the window is real too: the vulnerability details are public, the fixes are out, and the time from disclosure to a working exploit is usually just a matter of time.
The same release fixed more than these two flaws
Most people will remember the two 9.2 HTTP/2 flaws, but F5's security release addressed ten vulnerabilities in total, and the other eight are worth a look, because they show this was a concentrated cleanup rather than a one-off patch. Three more also scored 9.2: CVE-2026-121810, a use-after-free in HTTP/3, exploitable when configured with HTTP/3 as a proxy server, affecting 1.25.0 through 1.31.8; CVE-2026-123634, a use-after-free during response processing in the DNS resolver, with remote code execution when the attacker controls the upstream host name, affecting versions from 0.6.18 all the way to 1.31.8; and CVE-2026-113425, a use-after-free in the mail proxy module, with remote code execution when configured as a mail server proxy with auth_http, affecting 0.5.33 through 1.31.8. In other words, the 18 November batch contained five vulnerabilities scored 9.2 — three serious supporting players behind the two headliners.
The remaining five scored lower, but should not be dismissed outright. CVE-2026-118899 is an infinite loop while reading the client request body, a potential denial of service when the server supports TLS 1.3, scoring 8.7 and affecting 1.13.0 through 1.31.8. CVE-2026-120993 is a NULL pointer dereference, a denial of service when configured with proxy_protocol v2, scoring 6.9. CVE-2026-125283 is a buffer overflow when using alias with try_files, a theoretical remote code execution in an uncommon nginx.conf configuration, scoring 6.9 and affecting versions from 0.9.6. CVE-2026-123640 is insufficient validation in stream ssl_preread, allowing SSRF-like access when configured with ssl_preread, scoring 6.9. CVE-2026-120967 is a client certificate bypass in specific SNI configurations, scoring 6.3. Lower-scored flaws usually need stricter preconditions, but they are all on the same fix list, and upgrading to a fixed release resolves them all at once — there is no need to evaluate each one separately.
There is also an easy trap here: F5 shipped an NGINX security release in October too, and a server patched in October is not automatically safe. Cross-coverage states it plainly: F5 lists NGINX Open Source 1.31.8 as affected by CVE-2026-123633, so running a build newer than October's security release does not mean it contains the November fixes. Whether you are safe is decided by the version number and the fix list, not by "we patched last month."
What to do tonight: upgrade, turn off HTTP/2, or check first
The most direct action is to upgrade. For NGINX Open Source, the fixed releases are 1.30.7 on the stable branch and 1.31.9 on the mainline branch; both fix both vulnerabilities. For NGINX Plus, the fixed builds differ by CVE: 37.0.7.1 and 37.2.0.1 fix CVE-2026-123633, while 37.0.8.1 and 37.3.0.1 fix CVE-2026-123007, so pick a build that covers both. One exception needs special attention: NGINX Plus R-series releases R34 through R36 have no fix listed, and the recommendation is to move to a 37.x build that fixes both CVEs. For NGINX installed through a Linux distribution, or bundled inside another product's image, check the supplier's own security notice for the package or image, and confirm it contains both fixes rather than relying on the upstream version number alone.
If you cannot upgrade tonight, Wiz's stopgap is to temporarily disable HTTP/2 on affected NGINX instances: set http2 off in the affected server blocks on NGINX 1.25.1 or later, and remove the http2 parameter from any listen directives. Then test application compatibility, reload NGINX, and confirm the old workers have exited. Disabling HTTP/2 only reduces exposure; it does not fix the underlying flaws, so install the security update before turning the protocol back on. There is a similarly easy detail to miss after upgrading: a configuration reload alone does not replace the running NGINX binary, so restart the service, or roll out replacement containers as appropriate, and then verify the version actually running on every instance.
The order of triage matters too: start with internet-facing servers, then check internal proxies and static sites. As noted above, a server serving only static files is still in range of CVE-2026-123007, so the checklist cannot stop at reverse proxies and API gateways. For detection, Wiz offers two directions: exploiting CVE-2026-123007 requires sending a large number of WINDOW_UPDATE records to raise the counter to an arbitrary value, so long-standing HTTP/2 connections sending large amounts of data may hint at an attack; CVE-2026-123633 has different constraints and is more likely to be exploited when NGINX is configured as a proxy. More general warning signs are unexpected NGINX worker crashes or commands launched by NGINX — though Wiz cautions these are general signals, not confirmed indicators of these vulnerabilities. One more practical reality: CDNs and WAFs that terminate HTTP/2 may mitigate parts of an exploit by not reflecting the exact payload back to the underlying NGINX server, but that depends on implementation and cannot be treated as evidence of safety.
The age of AI digging up old debts has only just begun
The most memorable part of this incident may not be any single CVE number, but the trend it reveals: AI is systematically rewriting the economics of vulnerability research. In the past, a memory-safety flaw hiding in code for eleven years stayed hidden partly because finding it was so hard — it required tracing subtle interactions between memory operations and multiple code paths, and that workload was itself a barrier. Now AI-driven scanning tools like Wiz's Atlas are taking that barrier apart, and five independent teams hitting the same flaw in the same window suggests this is no longer one tool's lucky break. Wiz puts it directly in the post's conclusion: the flaws were already there; AI helped us find them.
That is the same coin for defenders and attackers. Defenders can find and fix flaws in widely deployed infrastructure faster, which should harden the software everyone depends on over time; but in the near term, faster discovery and a shorter window between disclosure and exploitation add to an already demanding workload for security teams. Wiz's advice is pragmatic: do not focus only on the patch itself, focus on how quickly you can reduce exposure in production — identify deployments running the affected version and configuration, prioritize the ones an attacker can reach, and apply mitigations while patches are tested and rolled out. Turning a published fix into protection in production still takes substantial manual work, from validating patches to coordinating rollouts with service owners.
For ordinary developers and operators, the lessons are concrete. First, infrastructure vulnerabilities are no longer "someone else's problem": however clean your application code is, a hole in the NGINX layer in front of it can take the whole stack down with it. Second, "we patched last month" is not a security state; the version number and the fix list are. Third, HTTP/2 and HTTP/3 themselves are becoming attack surface: this batch of ten flaws spans HTTP/2, HTTP/3, the DNS resolver, the mail proxy, and the stream module, which shows that a modern web server's attack surface stopped being a single port and a single config file long ago. And finally, the most important point: the next time you see a headline about a vulnerability that "hid for years," do not be surprised — treat it as the new normal. AI will only get faster at digging up old debts. The only question that matters is whether your patching is faster than its digging.
Comments (0)
Sources
Related articles
On 20 November 2026, OpenAI released MedChemBench: 99 medicinal-chemistry problems from 117 papers and patents, covering 761 molecules. GPT-6.2 Astra scores 84.5% overall — but 95.4% on assembling structures and only 50.4% on choosing compounds. The total flatters; the components tell the truth.
On 18 November 2026, Google Research and co-authors posted BuggyMLE to arXiv: bugs injected into 222 working ML repositories, and 14 models slide from 95% on the easiest tier to 9% on the hardest. A 9-billion-parameter model trained easy-to-hard beats Claude Opus 5.5 on the 10-bug tier.
On 19 November 2026, PostgreSQL 19 shipped — two months late, after a flood of AI-reported vulnerabilities rewrote the schedule. It brings REPACK (CONCURRENTLY), pg_plan_advice, and WAIT FOR LSN: tables can be reorganized while they run, query plans can be pinned, and standbys wait for your writes.