79% vs 51%: independent neobanks lag on app security. Read the report

Deep Dive

Deep Dive

NGINX2Root: Five NGINX RCEs, Fixed in 1.31.9 (CVE-2026-123007)

Five memory-safety flaws in nginx, led by an HTTP/2 flow-control underflow, let unauthenticated attackers run code as the worker. Fixed in 1.31.9 and 1.30.7.

TL;DR

  • NGINX2Root is five memory-safety flaws in nginx. The lead one, CVE-2026-123007, is an HTTP/2 flow-control underflow that an unauthenticated attacker can use to run commands as the nginx worker. Xint published the set on 2026-11-18.
  • Every official nginx release from 1.9.5 through 1.31.8 carries the lead flaw when HTTP/2 is enabled. The other four need a resolver with subrequests, an HTTP/2 or HTTP/3 proxy, or the mail proxy.
  • F5 scores all five at CVSS v4.0 9.2 Critical and CVSS v3.1 8.1 High. A public proof of concept exists for CVE-2026-123007, but no exploitation in the wild is reported. None is in CISA KEV as of November 19, 2026.
  • Upgrade to nginx 1.31.9 or 1.30.7, or NGINX Plus 37.3.0.1 or 37.0.8.1. If you cannot, disable HTTP/2 and the other affected features, with the limits described in "How do I fix it?".

Am I affected?

You are exposed when all of these conditions hold:

  • You run nginx Open Source 1.31.8 or earlier, from the first release that contains the flaw (see the table below), or an affected NGINX Plus release.
  • For CVE-2026-123007, the nginx binary was built with the HTTP/2 module and at least one server block enables HTTP/2.
  • For CVE-2026-123633, clients reach nginx over HTTP/2, nginx proxies their requests to a backend, and the worker can run low on worker_connections.
  • For CVE-2026-121810, clients reach nginx over HTTP/3, nginx proxies their requests, and the worker can run low on worker_connections.
  • For CVE-2026-123634, resolver is configured, proxy_pass contains a variable, and mirror or Server Side Includes resolve the same name in a subrequest.
  • For CVE-2026-113425, the mail block uses proxy on together with auth_http.

The five flaws are independent attack paths, so a server does not need every condition. CVE-2026-123007 affects servers that only serve static files, as long as HTTP/2 is on. The other four need the feature named in their bullet. NGINX Plus uses the same code and is affected on the branches F5 lists.

The scale is large. Xint counted 56.7 million nginx hosts on Shodan on 2026-11-10, and 11.94 million of them reported a version. Of those versioned hosts, 98.9% fell in the range affected by CVE-2026-123007. A reported version does not prove the flaw is reachable, because HTTP/2 must also be on and the build may already carry a backport.

Shodan counted 56.7 million nginx hosts and only 11.94 million with a version, so most cannot be checked by version alone
Figure 1: Internet-facing nginx hosts and the subset that reports a version. Source: Xint, citing Shodan, 2026-11-10, checked November 19, 2026

Branch Affected versions Fixed version
nginx 1.31 mainline 1.31.0 through 1.31.8 1.31.9
nginx 1.30 stable 1.30.0 through 1.30.6 1.30.7
Older nginx branches From 1.9.5 for CVE-2026-123007, 1.19.7 for CVE-2026-123633, 1.25.0 for CVE-2026-121810, 0.6.18 for CVE-2026-123634 and 0.5.33 for CVE-2026-113425 1.30.7 or 1.31.9
NGINX Plus 37.x 37.0.0 through 37.0.7.1, and 37.1.0 through 37.2.0.1 37.0.8.1 and 37.3.0.1
NGINX Plus R releases R33 in the CVE records; R34 through R36 in Rapid7's table No fixed release listed; follow F5's advisory

Check the binary that is actually running, not the one in your build files:

nginx -v 2>&1
nginx -V 2>&1 | grep -o -- '--with-http_v2_module'

A version in the affected range means the binary contains the vulnerable code, unless the distributor backported the fix. The second command prints --with-http_v2_module when the module is compiled in. An empty result means the HTTP/2 code is absent, so CVE-2026-123007 and CVE-2026-123633 cannot be reached on that binary.

Then look for HTTP/2 in the loaded configuration:

sudo nginx -T 2>&1 | sed 's/#.*//' \
  | grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'

Any output means HTTP/2 is enabled on that server block. Test from outside your network whether nginx answers HTTP/2 on the real port:

openssl s_client -connect example.com:443 -servername example.com \
  -alpn h2 </dev/null 2>&1 | grep -E 'ALPN protocol:|No ALPN negotiated'

ALPN protocol: h2 means the server accepts HTTP/2 directly. If a CDN or load balancer terminates HTTP/2 in front of nginx, repeat the test against the nginx host itself.

For the other paths, search the configuration for the feature each one needs:

sudo nginx -T 2>&1 | grep -nE 'resolver|mirror|proxy_pass.*\$|http3|quic|auth_http'

In a container, run the same checks inside the running container, for example docker exec <container> nginx -v. A freshly pulled image may differ from the process that is serving traffic.

How do I fix it?

Upgrade to nginx 1.31.9 on the mainline branch or 1.30.7 on the stable branch. nginx released both on 2026-11-18 with fixes for all five flaws. Mainline gets new features; the stable branch gets the same security fixes with fewer changes, which is usually the safer choice for production.

  1. On Debian or Ubuntu, update the nginx package and restart the service: bash sudo apt update sudo apt install --only-upgrade nginx sudo systemctl restart nginx
  2. On RHEL, AlmaLinux, Rocky Linux or Fedora, update the package set and restart: bash sudo dnf upgrade 'nginx*' sudo systemctl restart nginx
  3. On Alpine Linux, update the package and restart: bash sudo apk upgrade nginx sudo service nginx restart
  4. If you build nginx from source, rebuild against the 1.31.9 or 1.30.7 source and install the new binary. The release notes list every security fix in the release.
  5. In containers, rebuild from an updated base image and recreate the container. Pulling a new image does not replace the process that is already running.

For NGINX Plus, upgrade to 37.3.0.1 or 37.0.8.1, following F5's advisories, starting with K000163926 for CVE-2026-123007. The older R releases (R33 in the CVE records, R34 through R36 in Rapid7's table) have no fixed release listed, so follow F5's advisory for them.

A configuration reload does not replace the running executable. Restart nginx, or complete a supported live binary upgrade, and confirm that old workers have exited:

nginx -v 2>&1
ps -eo pid,args | grep '[n]ginx: worker process'

Distribution packages often backport fixes without changing the version string. AlmaLinux, for example, shipped patched packages on 2026-11-18 for every supported nginx stream while the reported nginx version stayed the same. Compare the full package version with your distribution's advisory, not only the output of nginx -v.

If you cannot upgrade, disable the affected feature. These steps do not fix the code, and each one covers only the flaws named.

  1. Disable HTTP/2 to block CVE-2026-123007 and CVE-2026-123633. On nginx 1.25.1 or later, set http2 off; in every affected server block and remove the http2 parameter from its listen directives. On older releases, remove http2 from listen 443 ssl http2;.
  2. Disable HTTP/3 to block CVE-2026-121810. Remove every listen ... quic directive, set http3 off, and replace an Alt-Svc header that advertises HTTP/3 with Alt-Svc 'clear'. Confirm that nothing still listens on UDP port 443.
  3. Remove request-time DNS lookups to block CVE-2026-123634. Point proxy_pass at a fixed upstream group instead of a name built from a variable. Turning mirror off helps only for the tested mirror path; SSI can reach the same bug, so a fixed upstream is the safer change.
  4. Restrict the mail proxy to block CVE-2026-113425. If nginx fronts IMAP, POP3 or SMTP with auth_http, bind the listeners to loopback or allow only trusted client addresses. Remote mail clients will lose access to the proxy.
  5. Block the SCTP module on hosts that do not need it. Xint chained the nginx flaws with a separate Linux kernel bug in SCTP, so add install sctp /bin/false to a file under /etc/modprobe.d/. This blocks new loads only; it does not unload a loaded module or disable SCTP built into the kernel.

Disabling HTTP/2 makes browsers fall back to HTTP/1.1, but native gRPC clients need HTTP/2 and will break. All five workarounds leave the vulnerable code in place, so install the fixed release as soon as you can.

After any change, reload the configuration and close existing connections. A reload applies to new connections only, so restart nginx if old HTTP/2 or mail sessions must not keep running with the old configuration.

What is the root cause?

The lead flaw is an accounting error in nginx's HTTP/2 flow control. nginx tracks how much response data each stream and the whole connection may still send. The protocol caps the connection window at 2^31-1 bytes.

nginx deducts credit when it queues response DATA, and returns that credit if the stream is cancelled before the DATA is sent. Both operations are valid on their own. The bug is that the refund has no upper-bound check, and the client can raise the window while the DATA is still queued.

At nginx 1.31.8, ngx_http_v2_send_chain() deducts the data length from the connection and stream windows:

/* src/http/v2/ngx_http_v2_filter_module.c:1241-1244, release-1.31.8 */
ngx_http_v2_queue_frame(h2c, frame);

h2c->send_window -= frame_size;

stream->send_window -= frame_size;
stream->queued++;

If the stream is then cancelled, ngx_http_v2_filter_cleanup() removes the unsent frames and adds their length back:

/* src/http/v2/ngx_http_v2_filter_module.c:1733, 1767, release-1.31.8 */
window += frame->length;
/* ... */
h2c->send_window += window;

A client can send a connection-level WINDOW_UPDATE after the DATA is queued and before the stream is cancelled. That raises send_window back to the maximum.

Cleanup then adds the same credit a second time. send_window becomes larger than NGX_HTTP_V2_MAX_WINDOW, which is (1U << 31) - 1.

The next connection WINDOW_UPDATE reaches the validation in ngx_http_v2_state_window_update():

/* src/http/v2/ngx_http_v2.c:2564-2575, release-1.31.8 */
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
    return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
}

h2c->send_window += window;

send_window is a size_t, so MAX_WINDOW - send_window is evaluated with unsigned arithmetic. Once send_window is higher than the maximum, the subtraction wraps to a very large positive number. The check treats the counter as having free capacity and accepts further increments. Repeating the exchange can raise send_window into the upper half of the 64-bit range.

The output filter then reads that value as a signed length:

/* src/http/v2/ngx_http_v2_filter_module.c:1144-1169, release-1.31.8 */
if (limit == 0 || limit > (off_t) h2c->send_window) {
    limit = h2c->send_window;
}
/* ... */
if ((off_t) frame_size > limit) {
    frame_size = (size_t) limit;
}
rest = frame_size;

A send_window near 2^64 becomes a small negative off_t. Both comparisons pass, and frame_size becomes a huge size_t. ngx_http_v2_filter_get_shadow() sets the buffer end pointer to pos + size, which points before the start.

The TLS output path computes last - pos as a negative ssize_t, then passes it to memcpy() as a huge size_t. On the tested x86-64 glibc, the backward copy wraps its end address and performs a limited out-of-bounds read and write instead of walking the whole range.

The other four flaws are use-after-free bugs with different lifetimes:

  • CVE-2026-123633: an HTTP/2 connection with a partially read frame stays in the reusable queue after a stream is created. A later drain can close that connection while the request still uses it.
  • CVE-2026-121810: a new HTTP/3 stream is inserted into the connection tree only after a connection slot is allocated. A drain during that allocation can close an idle stream on the same parent. The shutdown check then marks the parent reusable again, and a later drain closes it under the request.
  • CVE-2026-123634: the resolver loop saves the next waiting context before calling a handler. A handler can free a later context for the same request, and the loop then uses the freed memory.
  • CVE-2026-113425: a default reply stays queued when the mail proxy starts an auth_http lookup. If the client resets the connection, the failed write destroys the session while the authentication connection still points to it.

How is it exploited?

CVE-2026-123007 is exploited over a normal HTTPS connection with HTTP/2 enabled.

  1. The client opens an HTTP/2 connection and sets SETTINGS_INITIAL_WINDOW_SIZE to 0, so nginx can create response headers but cannot send response DATA.
  2. The client stops reading and sends PING frames. nginx queues the acknowledgements ahead of the response DATA and fills the TLS and TCP send buffers, so the DATA stays in nginx's output queue.
  3. The client grants each stream enough credit for its response body, then raises the connection window to the maximum. nginx queues the DATA and deducts its length from the connection window.
  4. The client sends RST_STREAM for the streams. Cleanup removes the unsent DATA and returns its credit, pushing the connection window past the maximum.
  5. The client sends more WINDOW_UPDATE frames. The unsigned check underflows, accepts them, and raises the connection window towards 2^64.
  6. The next response produces a negative length and an out-of-bounds copy. Addresses disclosed in the response and attacker-controlled bytes in the heap let the attacker redirect a cleanup callback and run a command as the worker.

Rapid7's public proof of concept implements this chain against a local Docker image and reports about 119 GiB (roughly 128 GB) of HTTP/2 plaintext; TLS and network overhead add more on the wire. Rapid7 estimates about two minutes on a 10 Gbit/s link and about seventeen minutes on a 1 Gbit/s link.

A link slower than roughly 300 Mbit/s exceeds nginx's default one-hour connection lifetime.

The proof of concept is tuned for a fresh local container and a specific glibc copy routine. Wiz Research independently demonstrated code execution with an ASLR bypass on official 1.31.7 and 1.31.8 builds serving static files.

The other four paths have their own preconditions:

  • CVE-2026-123633 needs an HTTP/2 proxy and a worker low on connection slots. Xint triggered the drain while the request connected to its upstream.
  • CVE-2026-121810 needs an HTTP/3 proxy and the same connection pressure.
  • CVE-2026-123634 needs a resolver lookup for a variable upstream name and a subrequest for the same name. The attacker must also be able to answer the DNS query that nginx sends.
  • CVE-2026-113425 needs the mail proxy with auth_http, and a client that can reset its connection during login. No valid credentials are required.

How does the attack flow?

The lead chain turns HTTP/2 window accounting into an out-of-bounds copy, then into a worker command.

flowchart LR A["Client queues DATA and raises
the connection window"] --> B["Stream cancel refunds credit
with no upper-bound check"] B --> C["Connection window exceeds
the 2^31-1 maximum"] C --> D["Next WINDOW_UPDATE check
underflows and accepts more credit"] D --> E["send_window reaches the
upper half of 64 bits"] E --> F["Signed length becomes negative
and the buffer end precedes its start"] F --> G["TLS copy reads and writes
outside the buffer"] G --> H["Leaked addresses and heap overwrite
run a command as the worker"]

What can an attacker do?

An unauthenticated attacker can run commands with the permissions of the nginx worker process. The worker usually runs as the nginx or www-data user, so the attacker gains that account, not root. A worker compromise can expose every site and API that worker serves, with the worker's access to files and environment variables.

CVE-2026-123007 needs HTTP/2 enabled and a response body nginx can queue. Wiz demonstrated it on a server that only served static files, with no backend application.

Rapid7's chain needs about 119 GiB of plaintext and a suitable glibc copy routine, so remote exploitation is constrained by bandwidth, timeouts and heap layout. F5 says code execution requires ASLR to be disabled or bypassed, and both Xint and Wiz demonstrated an ASLR bypass.

The other four flaws can crash a worker with a crafted request. Code execution through them also depends on heap grooming and an address leak; Xint demonstrated command execution on each path in its lab.

Xint also chained CVE-2026-123007 with a separate use-after-free in the Linux kernel's SCTP subsystem. In its tests that chain gave root on the host and escaped a Docker container running nginx.

Xint names no CVE for that kernel bug, and it is withholding the details needed to reproduce it until a kernel patch is available. The nginx flaw alone gives the worker account.

No exploitation in the wild is publicly reported for any of the five. None is in CISA KEV as of November 19, 2026, and the latest catalog version is 2026.11.18.

Why does the fix work?

The fix counts queued DATA as part of the connection window, so the validation no longer sees capacity that cleanup is about to return. Commit e27f5fa8 added a send_queued field and subtracted it from the allowance in the WINDOW_UPDATE check:

--- a/src/http/v2/ngx_http_v2.c
+++ b/src/http/v2/ngx_http_v2.c
@@ -2561,13 +2561,13 @@ ngx_http_v2_state_window_update(...)
         return ngx_http_v2_state_complete(h2c, pos, end);
     }

-    if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
+    if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {
         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
                       "client violated connection flow control: "
                       "received WINDOW_UPDATE frame "
                       "with window increment %uz "
                       "not allowed for window %uz",
-                      window, h2c->send_window);
+                      window, h2c->send_window + h2c->send_queued);

         return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
     }

ngx_http_v2_send_chain() increments send_queued when it queues a frame, and decrements it when the frame is sent or removed by cleanup:

--- a/src/http/v2/ngx_http_v2_filter_module.c
+++ b/src/http/v2/ngx_http_v2_filter_module.c
@@ -1242,6 +1242,7 @@
             ngx_http_v2_queue_frame(fn, frame);

             h2c->send_window -= frame_size;
+            h2c->send_queued += frame_size;

             stream->send_window -= frame_size;
             stream->queued++;
@@ -1634,6 +1635,7 @@
     stream->request->header_size += NGX_HTTP_V2_FRAME_HEADER_SIZE;

     h2c->payload_bytes += frame->length;
+    h2c->send_queued -= frame->length;

     ngx_http_v2_handle_frame(stream, frame);

@@ -1770,6 +1772,7 @@
     }

     h2c->send_window += window;
+    h2c->send_queued -= window;
 }

With the counter in place, MAX_WINDOW - send_window - send_queued stays non-negative for any accepted state. A client that tries to push the window past the limit now receives FLOW_CTRL_ERROR before the counter can wrap. The refund still happens, but it returns credit that the check still counts as queued, so the double addition cannot escape the maximum.

nginx credits Xint for CVE-2026-123007, CVE-2026-123634, CVE-2026-121810 and CVE-2026-113425, and Albert of Vexera AI for CVE-2026-123633. Maxim Dounin shares the credit for CVE-2026-113425, and the CVE record for CVE-2026-123007 also credits Rapid7, Wiz Research and Ikotas Labs. The release also fixes CVE-2026-118899, an unauthenticated denial of service over TLS 1.3, and four other security issues in 1.31.9 (three in 1.30.7). It also carries a separate fix for each of the other four nginx2root flaws:

  • CVE-2026-123633: commit 2df48a50 clears the reusable flag in ngx_http_v2_create_stream(), so a connection with a new stream cannot be drained. Its author date, 2026-09-17, precedes Xint's discovery: the commit credits an earlier report from Albert of Vexera AI.
  • CVE-2026-121810: commit b5252dae inserts the new QUIC stream into the connection tree before allocating a connection slot, so a drain sees it and cannot mark the parent idle.
  • CVE-2026-123634: commit e39708ed installs a finalizer in ctx->handler and defers the free when the context is already detached from the waiting list.
  • CVE-2026-113425: commit 754fe68c clears the queued default reply with s->out.len = 0 when auth_http starts, so a failed write cannot destroy the session during the lookup.

How do I check if I was compromised?

An attack with CVE-2026-123007 can leave little in the access log. The WINDOW_UPDATE and RST_STREAM frames are control frames, not requests, and TLS encrypts them in transit. Start with the network and process checks.

Look for a long-lived HTTPS connection that receives far more than it sends:

sudo ss -tinp state established '( sport = :443 )'

Run the command twice and compare bytes_received and bytes_sent. A connection from one external address that stays open for minutes, keeps receiving at a high rate, and sends little back matches the tested traffic pattern. Many short TLS connections from the same address at the same time are a second signal.

Add the connection ID and request length to the access log in the http block, then compare logged request bytes with the socket counters:

log_format h2_hunt '$time_iso8601 src=$remote_addr conn=$connection '
                   'requests=$connection_requests proto=$server_protocol '
                   'status=$status request_length=$request_length '
                   'bytes_sent=$bytes_sent request_time=$request_time';

access_log /var/log/nginx/h2-hunt.log h2_hunt;
sudo nginx -t && sudo nginx -s reload
sudo grep 'proto=HTTP/2.0' /var/log/nginx/h2-hunt.log | tail -n 200

If bytes_received for one connection keeps growing while its logged request_length stays small, the client is sending data that never appears as requests. That is a lead, not proof, because a large upload can look similar.

A successful exploit runs a program from the nginx worker. Find the worker's user ID and audit executions by that UID:

ps -eo uid,user,pid,ppid,args | grep '[n]ginx: worker process'
sudo auditctl -a always,exit -F arch=b64 -S execve,execveat \
  -F euid=NGINX_UID -k nginx_worker_exec
sudo ausearch -k nginx_worker_exec -ts recent -i

Replace NGINX_UID with the numeric UID from the first command. The rule records only events after it is installed, so an empty result does not rule out an earlier compromise. It also matches other processes that run under the same UID.

Check for abnormal worker exits and core dumps:

sudo grep -Ei 'worker process.*exited|signal 11|segfault' /var/log/nginx/error.log
sudo coredumpctl list nginx

A worker crash has many causes, so correlate it with the other signals. Xint, Rapid7 and Wiz published no file names, domains or IP addresses for these flaws. An attempt that failed may leave little or no trace.

Timeline

  • 2026-10-11: Xint's research team discovers the five nginx flaws.
  • 2026-10-16: Xint reports them to F5 through HackerOne.
  • 2026-10-20: HackerOne completes validation.
  • 2026-10-27: The reports reach the nginx development team.
  • 2026-11-09: The nginx team requests patch validation.
  • 2026-11-10: Xint completes patch validation.
  • 2026-11-11: Rapid7 contacts F5 about CVE-2026-123007, which it found independently.
  • 2026-11-18: nginx releases 1.31.9 and 1.30.7, the CVE records are published, and Rapid7 releases its proof of concept.

The releases followed Xint's discovery by 38 days. For CVE-2026-123633, Git records an author date of September 17 and a committer date of November 11 for the upstream fix.

Xint discovered the flaws on 2026-10-11 and nginx released fixes 38 days later, on 2026-11-18
Figure 2: Disclosure, validation and release dates for the five flaws. Source: Xint, checked November 19, 2026

FAQ

Is NGINX2Root exploited in the wild?

No public report of exploitation exists as of November 19, 2026. None of the five CVEs is in CISA KEV, whose latest catalog is 2026.11.18. That can change quickly after a public proof of concept, so treat exposed servers as urgent.

Does disabling HTTP/2 fix all five flaws?

No. Disabling HTTP/2 blocks CVE-2026-123007 and CVE-2026-123633 only. CVE-2026-123634 needs a fixed upstream or a resolver change, CVE-2026-121810 needs HTTP/3 disabled, and CVE-2026-113425 needs the mail proxy restricted.

I use my distribution's nginx package. Is nginx -v enough?

No. Distributions backport fixes without changing the nginx version string. Compare the full package version with the distribution's security advisory. AlmaLinux published fixed packages on 2026-11-18 for its supported streams while the version stayed at 1.20, 1.24 or 1.26.

How practical is the public exploit?

It is a working proof of concept, not a universal remote exploit. Rapid7's chain sends about 119 GiB of plaintext and is tuned for a fresh local Docker container. Wiz demonstrated a separate chain with an ASLR bypass and has not released it.

Does a CDN or WAF protect nginx?

Only sometimes. A proxy that terminates HTTP/2 and does not forward the attacker's control frames can break the chain, but this depends on the implementation. Patch nginx instead of relying on the proxy.

Is the SCTP kernel flaw part of nginx2root?

It is the second half of the name, but it is a separate Linux kernel bug. Xint names no CVE for it and is withholding the details until a kernel patch is available. Hosts that do not use SCTP can block the module as described in "How do I fix it?".

References

  • Xint, "NGINX2Root: New Remote Code Execution Vulnerabilities in nginx Require Urgent Patching", 2026-11-18 (checked November 19, 2026). https://xint.io/blog/nginx2root-remote-code-execution
  • nginx, "nginx security advisories", 2026-11-18 (checked November 19, 2026). https://nginx.org/en/security_advisories.html
  • nginx, "Changes with nginx 1.31.9", 2026-11-18 (checked November 19, 2026). https://nginx.org/en/CHANGES
  • nginx, "Changes with nginx 1.30.7", 2026-11-18 (checked November 19, 2026). https://nginx.org/en/CHANGES-1.30
  • nginx, commit e27f5fa8, "HTTP/2: account for queued frames when validating WINDOW_UPDATE", 2026-10-29 (checked November 19, 2026). https://github.com/nginx/nginx/commit/e27f5fa84fe6e98505e70bc543b748747dad0a3b
  • nginx, commit 2df48a50, "HTTP/2: reset reusable connection status on stream creation", authored 2026-09-17, committed 2026-11-11 (checked November 19, 2026). https://github.com/nginx/nginx/commit/2df48a501d0fb8212b7d39dffeeff5876332ba59
  • nginx, commit b5252dae, "QUIC: avoid main connection reuse after creating a stream", 2026-11-01 (checked November 19, 2026). https://github.com/nginx/nginx/commit/b5252dae1ca0d4c516b8bcffd9fa7fd967b73075
  • nginx, commit e39708ed, "Resolver: fix non-current resolve finalization from resolve handler", 2026-10-28 (checked November 19, 2026). https://github.com/nginx/nginx/commit/e39708edc69a9c0c992b6af075db761946969534
  • nginx, commit 754fe68c, "Mail: fixed use-after-free on client reset during auth_http request", 2026-11-04 (checked November 19, 2026). https://github.com/nginx/nginx/commit/754fe68c2e0f698baf731666e71b7f2619c715ef
  • CVE Program, "CVE-2026-123007", 2026-11-18 (checked November 19, 2026). https://www.cve.org/CVERecord?id=CVE-2026-123007
  • CVE Program, "CVE-2026-123633", 2026-11-18 (checked November 19, 2026). https://www.cve.org/CVERecord?id=CVE-2026-123633
  • CVE Program, "CVE-2026-123634", 2026-11-18 (checked November 19, 2026). https://www.cve.org/CVERecord?id=CVE-2026-123634
  • CVE Program, "CVE-2026-121810", 2026-11-18 (checked November 19, 2026). https://www.cve.org/CVERecord?id=CVE-2026-121810
  • CVE Program, "CVE-2026-113425", 2026-11-18 (checked November 19, 2026). https://www.cve.org/CVERecord?id=CVE-2026-113425
  • Rapid7, "CVE-2026-123007: Critical NGINX HTTP/2 Integer Underflow Leads to RCE (FIXED)", 2026-11-18 (checked November 19, 2026). https://www.rapid7.com/blog/post/ve-cve-2026-123007-critical-nginx-http-2-integer-underflow-leads-to-rce-fixed/
  • Rapid7, proof-of-concept repository for CVE-2026-123007, 2026-11-18 (checked November 19, 2026). https://github.com/sfewer-r7/CVE-2026-123007
  • Wiz Research, "Unauthenticated Remote Code Execution in NGINX: CVE-2026-123633 and CVE-2026-123007", 2026-11-18 (checked November 19, 2026). https://www.wiz.io/blog/nginx-http2-rce-vulnerabilities
  • AlmaLinux, "NGINX2Root: Patched nginx packages released", 2026-11-18 (checked November 19, 2026). https://almalinux.org/blog/2026-11-18-nginx2root/
  • CVE Program, "CVE-2026-118899", 2026-11-18 (checked November 19, 2026). https://www.cve.org/CVERecord?id=CVE-2026-118899
  • F5, security advisory K000163926 for CVE-2026-123007, 2026-11-18 (checked November 19, 2026). https://my.f5.com/manage/s/article/K000163926
  • CISA, "Known Exploited Vulnerabilities Catalog", 2026-11-18 (checked November 19, 2026). https://www.cisa.gov/known-exploited-vulnerabilities-catalog