Skip to main content
Mallory
CriticalPublic exploitVulnerability

CVE-2026-123007: NGINX HTTP/2 Flow-Control Integer Underflow and Remote Code Execution

Published Nov 18, 2026 · Updated today
Trending this week#2of 430,175 vulnerabilities
Mention activity · 30 daysAt least 200 mentions · peak 140 in a dayToday
CVSS9.2Critical · v4
EPSS6.4%94th percentile
CISA KEVNoNot listed
In the wildNonePublic exploit, no exploitation reported
IdentifiersCVE-2026-123007CWE-191 · Integer Underflow (Wrap or…

CVE-2026-123007 is an integer-underflow vulnerability in ngx_http_v2_module affecting HTTP/2-enabled NGINX Open Source and NGINX Plus deployments. Cancellation of an HTTP/2 stream can restore unused sending credit without enforcing the connection flow-control window's protocol maximum. Subsequent WINDOW_UPDATE bounds checking can underflow, allowing an invalid send-window value that ultimately becomes an unsafe memory-copy length in buffered output processing. This can cause out-of-bounds heap reads and writes, worker segmentation faults, and potentially remote code execution. The vulnerable functionality originated in NGINX 1.9.5; affected upstream releases include versions through 1.30.6 and mainline 1.31.0–1.31.8, unless separately patched. Static-file servers are affected; reverse proxying and third-party modules are not required. The vulnerability is part of the NGINX2Root group and affects the data plane, not the control plane.

Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Analyst brief

Impact, mitigation & remediation

What it means and what to do now: patch path, interim mitigations, and the assume-compromise checklist.

Impact

What an attacker gets, and what they’ve been doing with it.

Unauthenticated remote attackers can crash NGINX worker processes, corrupt worker memory, potentially disclose process memory, and execute arbitrary code when ASLR is disabled or bypassed. Successful code execution occurs with NGINX worker-process privileges, potentially exposing accessible application data and credentials, enabling response modification, or disrupting multiple applications sharing the instance. Root access and container escape are not inherent consequences; demonstrated escalation chains require a separate Linux kernel vulnerability.

Mitigation

If you can’t patch tonight, do this now.

If patching is delayed, disable HTTP/2 on every affected listener by setting 'http2 off;' where supported and removing the legacy 'http2' parameter from listen directives. Apply the configuration, ensure old workers have exited, and verify that affected endpoints no longer accept HTTP/2, including directly reachable origins behind intermediaries. Test compatibility because gRPC and other HTTP/2-dependent services may fail. HTTP/2 termination at a CDN or proxy may disrupt particular exploit implementations but is not a reliable substitute for patching. Retain ASLR, restrict worker privileges and network access, and monitor for worker crashes, unusually large or long-lived HTTP/2 sessions, and unexpected worker-launched processes.

Remediation

Patch, then assume compromise.

Upgrade NGINX Open Source to stable 1.30.7, mainline 1.31.9, or a later fixed release. Upgrade NGINX Plus to 37.0.8.1 or 37.3.0.1, as appropriate for the release line; affected older branches without a fixed build must migrate to a supported fixed release. For distribution packages, embedded products, and container images, install the supplier's corrected packages or images and account for backported fixes rather than relying solely on upstream version strings. Fully restart NGINX or perform an appropriate live binary upgrade, and verify that the patched executable is running and vulnerable workers have exited. A configuration reload alone does not replace the executable.

Public exploits

Exploits

5 exploits validated by Mallory's analysis. Hidden: 13 rejected by Mallory's analysis as not a working exploit.

View more in app →
CVE-2026-123007The repository contains a standalone, componentized RCE implementation and a separate accounting/crash trigger for the repository-identified CVE-2026-123007. The visible code supports a substantive exploit chain rather than merely banner-based detection, and shows no obvious fake-exploit behavior. This is a static assessment: several supplied files are truncated, and neither the CVE attribution nor the documented live successes were independently verified. The root cause described in cli.py is incorrect restoration of queued HTTP/2 DATA credit during stream cleanup following a SETTINGS overflow. This leaves the unsigned connection send window above the protocol maximum, causing the WINDOW_UPDATE bounds calculation to wrap. Billions of accepted updates subsequently produce a negative signed output limit. NGINX constructs an inverted buffer and passes an enormous converted length to memcpy during TLS output staging. With the calibrated glibc copy implementation, this exposes heap/libc data and overwrites an adjacent request pool. The client derives ASLR-sensitive addresses from the disclosure, reclaims overlapping allocations, and installs a cleanup callback invoking system(command). The 1.31.6 profile uses a fixed libc-relative system offset; the 1.31.8 path supports address-directed memory disclosure, in-band ELF symbol resolution, and deferred callback execution. exploit/exploit.py is the compatibility launcher. The 11-module nginx_rce package separates CLI validation, target routing and fingerprinting, HTTP/2/HPACK and explicit-key TLS, bootstrap accounting manipulation, native bulk-sender supervision, leak interpretation, heap reclaim, and stage orchestration. streamer.c implements a constant-memory TLS record sender over an inherited connected socket. The full schedule is approximately 119 GiB of application plaintext according to the implementation documentation, making bandwidth, timing, and resource consumption significant. The helper executable is required but is not present in the supplied 32-file inventory and must be compiled. Two JSON profiles identify exact NGINX 1.31.6 and 1.31.8 builds and encode transport, allocator, object-layout, and libc calibration. Profile selection checks TLS 1.3/h2, ordered SETTINGS, server headers, stable response geometry, Range behavior, and later leaked-pointer invariants. Expected SETTINGS are [[3,128],[4,65536],[5,16777215]] for 1.31.6, with [9,1] appended for 1.31.8. Profile validation deliberately rejects incompatible or ambiguous configurations. profile_tool.py provides offline validation, candidate ELF inventory, unvalidated template generation, and a separate non-exploiting remote fingerprint mode. The inventory comprises 23 Python files, one C source file, two JSON profiles, five Markdown documents, and one dependency file. The tests directory contains fixtures and seven test modules covering protocol bytes, native-helper accounting, profiles, disclosures, stage ordering, routing, and cleanup; the documentation reports 35 passing component tests, which were not run for this analysis. simple-trigger-poc.py independently demonstrates the accounting error and advances to a deliberately fatal signed-copy state without implementing the RCE reclaim chain. The reproduction guide supplies the local Docker/TLS environment and records constrained clean-start successes, not a general reliability guarantee. Targets and payload commands are operator supplied. No hardcoded external exfiltration or command-and-control endpoint is visible. Loopback URLs and container paths are reproduction artifacts, and test marker paths are synthetic fixtures. Repository URL, git reference, and archive size were not supplied; their metadata fields are left empty or use zero as an unavailable-value placeholder.sfewer-r7 · Disclosed Nov 18, 2026 · python · c · network · webOperationalnginx-exploitsThe repository contains two Markdown documents and two standalone Python CLI programs. The root README indexes the claimed vulnerabilities; the nested README describes mechanisms, affected releases, usage, and mitigations. exploit.py identifies itself as version 2.2.1 and includes reverse-shell templates, post-exploitation command definitions, threaded target handling, resume support, and JSON/JSONL reporting. poc.py identifies itself as version 2.1.0 and is presented as a detection tool, with explicit version-range tables, threaded scanning, retries, and structured results. Visible imports are Python standard-library modules; no framework integration is evident. The documentation alleges an unauthenticated HTTP/2 UAF involving incomplete HEADERS and connection draining, plus a send_window arithmetic flaw involving stream cancellation and WINDOW_UPDATE traffic leading to TLS-path out-of-bounds access. Both scripts define HTTP/2 frame constants and the standard connection preface. However, their central networking, detection, and exploitation routines are omitted by truncation. Consequently, the supplied excerpts establish exploit intent and payload availability, not a working RCE chain, reliable detection, or authenticity of the CVE/version/patch claims. A visible default handler-offset description references NGINX 1.18.0, outside the documented UAF range, indicating a target-layout assumption requiring further scrutiny. The repository is not detection-only because it includes an exploitation program and shell payloads. OPERATIONAL denotes the presence of basic payload definitions, not independently verified exploit reliability. No affirmative evidence establishes that it is fake; likewise, the available material cannot establish validity. The /tmp/f removal belongs to a conventional FIFO shell template rather than broad destructive behavior. No fixed command-and-control or exfiltration server is visible. Documentation badges, author links, and example addresses are not observed runtime destinations. The original repository URL, git reference, and archive size were not supplied; empty strings and zero represent unavailable metadata. Listed file sizes sum to 84,234 bytes, which is not an archive-size measurement.Ghost-Bx1 · Disclosed Nov 18, 2026 · python · networkOperationalnginx2root-rce-labThis is a standalone reproduction and calibration toolkit, not a self-contained exploit client or a recognized exploit-framework module. Its 27 files comprise eight source/script files, one JSON target profile, bilingual documentation, licensing/disclaimer material, and sanitized execution evidence. No original repository URL, git ref, or archive size was supplied; empty strings and size 0 represent unavailable metadata. The documented vulnerability chain double-refunds HTTP/2 flow-control credit, wraps a connection window into a negative signed value, and converts it into an enormous memcpy length in the TLS staging path. The referenced external client reportedly turns the resulting overlapping heap copy into two disclosures, ASLR resolution, heap reclamation, and a system() callback. These mechanism and vulnerability claims are supplied by the repository and were not independently verified. Documentation claims affected versions 1.9.5–1.31.8 and fixes in 1.31.9/1.30.7; included success evidence concerns only 1.31.7 and 1.31.8. Despite the nginx2root branding, the evidence describes unprivileged nginx-worker execution, with no demonstrated root escalation or container escape. scripts/setup_target.sh creates a loopback-exposed Docker target with a supplied nginx configuration and temporary TLS certificate. scripts/run_attempt.sh restarts that target, invokes the separately obtained exploit with a configurable command, and checks a marker. scripts/collect_evidence.sh collects version, HTTP/2 headers, memcpy diagnostic output, marker metadata/content, and worker-exit logs. The setup is not fully pinned as written: its default uses an image tag rather than an immutable digest. tools/ contains four Python utilities and one C diagnostic: a TLS/HTTP/2 SETTINGS probe; a stripped-ELF anchor scanner using relative function-pointer relations and prologue heuristics; a cross-binary leading-byte signature matcher; a profile generator extracting binary identities with SHA-256/readelf; and a process-local memcpy IFUNC checker. The supplied 1.31.7 profile stores target hashes, protocol fingerprints, pointer deltas, and detailed transport/heap layouts. The binary-matching tools are heuristic and do not establish exploit compatibility by themselves. The main research emphasis is that compatible 32-byte-vector AVX/YMM memcpy geometry can substitute for the profile's EVEX/YMM implementation. Included evidence claims successful marker execution with AVX/YMM and second-disclosure failure with SSE/XMM. Attempts reportedly send about 119 GiB over roughly six minutes, including billions of WINDOW_UPDATE frames, and can terminate a worker with signal 6. These are conspicuous, disruptive lab attempts, not lightweight vulnerability checks. The SETTINGS probe alone fingerprints protocol behavior and cannot confirm vulnerability. No external callback, exfiltration destination, reverse-shell listener, or persistence mechanism appears in the supplied code. Reference websites are documentation links rather than runtime network destinations. Evidence remains self-reported: the profile's validation statement is dated 2026-11-19, one day after the supplied analysis date of 2026-11-18, which is a provenance inconsistency but does not by itself establish that the repository is fake.WormW · Disclosed Nov 18, 2026 · bash · python · network · webOperationalNGINX2Root-CVE-2026-123007The supplied repository contains a standalone Rust exploit client, not merely a detector: 13 Rust source files, one Bash validation script with embedded Python, two JSON target profiles, Cargo metadata, two Markdown documents and a gitignore, totaling 21 files. The code implements a substantive exploitation chain consistent with its stated purpose; however, several files are truncated in the supplied content, and neither successful compilation nor exploitation was independently verified. The CVE attribution and stated fixes in nginx 1.30.7/1.31.9 are repository claims, not independently established findings. The default safe mode probes a resource, manipulates HTTP/2 flow-control accounting and checks for two FLOW_CONTROL_ERROR stream resets, a ten-byte response release, a subsequent PING acknowledgment and a still-open connection. It supports multiple supplied origins or a target-list file and reportedly sends approximately 14 MiB per check. A positive result establishes the accounting behavior, not RCE. The full chain first refunds credit for queued DATA after the connection window has been raised to its maximum, causing the subsequent window-limit guard to underflow. A large carrier transfer and approximately 2^33 WINDOW_UPDATE frames then drive the counter to a calibrated wrapped value. The resulting oversized memcpy operation is intended to disclose heap, libc and nginx memory. The 1.31.8 profile expects 14,393 disclosed bytes. Heap grooming and 16 auxiliary connections reclaim overwritten allocations, install forged pool/cleanup objects and redirect execution to system(command). The newer profile includes live ELF symbol resolution; the legacy profile stores a fixed system offset. Full exploitation reportedly consumes approximately 119 GiB and can crash a worker. Repository responsibilities are separated: main.rs and cli.rs handle modes and arguments; runner.rs orchestrates stages and profile selection; target.rs handles origins, address resolution and resource sizing; h2.rs implements HTTP/2 framing and minimal HPACK; tls.rs uses an OpenSSL handshake followed by a custom TLS 1.3 record layer; bootstrap.rs and bulk.rs implement the accounting and wrap stages; leak.rs interprets disclosures and constructs forged objects; reclaim.rs prepares heap layouts and execution records; profile.rs validates embedded or external calibration data; limits.rs handles timing and logging; shell.rs implements callback acceptance, output verification and interactive relay. The validation script builds local nginx versions, serves an 896-byte fixture and checks safe-mode outcomes. Its scoped temporary-directory removal is test setup, not evidence of a destructive fake exploit. Fingerprinting includes Server headers, ordered HTTP/2 SETTINGS, resource-derived request counts and disclosed native-object invariants. No fixed external command-and-control or exfiltration destination is visible: target and callback addresses are operator supplied, while loopback addresses serve tests. Documentation example domains and dependency registry URLs are not exploit destinations. Shell confirmation checks for uid= but is not cryptographic proof of callback origin. Repository URL, analyzed git reference and archive size were not supplied; their fields use empty strings and zero as unavailable-value placeholders.arkrwn · Disclosed Nov 18, 2026 · rust · bash · network · webOperationalnginx-http2-cve-2026-123007-labThe supplied repository is a standalone nginx HTTP/2 exploitation lab containing 23 files, including 12 Python files, one C source file, and one shell script. Other files provide Docker configuration, a calibrated JSON profile, dependency pins, documentation, and SVG artwork. It includes real exploit logic rather than only detection or documentation, but execution and the claimed CVE/advisory details were not independently verified. Several substantial source files are truncated in the supplied material, so this is a static assessment of the visible implementation and accompanying claims. The intended vulnerability chain abuses response-credit refunds during stream cleanup to leave the unsigned connection send window above HTTP/2's 31-bit maximum. A subsequent WINDOW_UPDATE check then underflows. Repeated increments move the window into a state interpreted as a negative signed output limit, producing an inverted buffer and an oversized memcpy operation. The RCE engine attempts to turn the resulting disclosure and overwrite into ASLR address recovery, controlled request-pool reclamation, and cleanup-callback execution through libc system(). The initial invariant violation uses one primary connection; the complete RCE implementation also opens 16 auxiliary connections. exploit.py is the main wrapper, offering a default vulnerability check, an optional bandwidth-heavy crash amplifier, and user-selected command execution. engine/nginx_rce separates transport and HTTP/2/HPACK handling, bootstrap/window manipulation, native bulk-sender supervision, profile validation, disclosure interpretation, heap reclamation, and final dispatch. runner.py sequences these stages and closes connections afterward. streamer.c generates authenticated TLS 1.3 traffic using inherited socket state and traffic secrets in constant memory; Python validates its traffic and sequence-number ledger before adopting the resulting state. Profile matching uses server headers, HTTP/2 SETTINGS, resource behavior, and leaked-pointer invariants, rejecting unsupported or ambiguous targets. Only one target profile is supplied: nginx 1.31.8 on Debian 13 amd64 with a specific glibc/OpenSSL combination and EVEX/YMM memcpy behavior. Broader affected-version ranges are documentation claims, not evidence of portable RCE support. The documented RCE traffic cost is approximately 119 GiB; crash mode is described as approximately 60 GiB. Dispatch logging explicitly requires an external oracle to establish command execution and does not prove success by itself. The docker directory builds a digest-pinned server image, enables HTTP/2 over TLS, creates a self-signed certificate, and binds the lab to 127.0.0.1:19443. README.md and article.md explain the claimed flaw, reproduction, and mitigation. No fixed command-and-control or exfiltration endpoint is visible; advisory and GitHub links are documentation references. The README also lists assets absent from the supplied inventory, including cover.png and assets/underflow.gif. The repository URL is inferred from its self-reference in article.md; the analyzed git reference and archive size were not supplied, with size_bytes set to 0 as an unknown-value placeholder.akarkode · Disclosed Nov 19, 2026 · python · c · network · webOperational
FAQ

Frequently asked questions

Is CVE-2026-123007 exploited in the wild?
As of Nov 19, 2026, Mallory has no reports of CVE-2026-123007 being exploited in the wild. It is not listed in CISA KEV.
Is there a public exploit for CVE-2026-123007?
Yes. Mallory tracks 5 public exploits or proofs of concept for CVE-2026-123007, the earliest disclosed Nov 18, 2026.
Is there a patch for CVE-2026-123007?
Upgrade NGINX Open Source to stable 1.30.7, mainline 1.31.9, or a later fixed release. Upgrade NGINX Plus to 37.0.8.1 or 37.3.0.1, as appropriate for the release line; affected older branches without a fixed build must migrate to a supported fixed release.
How severe is CVE-2026-123007?
CVE-2026-123007 has a CVSS v4 score of 9.2 (Critical) and an EPSS score of 6.4% (94th percentile) as of Nov 19, 2026.
Activity feed

Recent activity

446 sources tracked across advisories, community write-ups, and news. New activity surfaces here as Mallory finds it.

View more in app →
si cert blogNews · Nov 19, 2026SI-CERT 2026-09 / Kritične ranljivosti v spletnem strežniku NGINX - nginx2root - SI CERTAn integer overflow in NGINX HTTP/2 processing can cause a heap buffer overflow and permit unauthenticated remote code execution with NGINX worker-process privileges. Exploitation requires HTTP/2 to be enabled. The advisory assigns CVSS 8.1 and states that the flaw has existed since NGINX 1.9.5. It is one of five vulnerabilities collectively called NGINX2Root. Fixed NGINX Open Source releases are 1.30.7 and 1.31.9; disabling HTTP/2 is a temporary mitigation.Read more ↗socprime blogNews · Nov 19, 2026CVE-2026-123007: Critical NGINX2Root RCEA critical NGINX HTTP/2 flow-control memory-corruption vulnerability, rated CVSS v4 9.2. Manipulated window accounting can cause integer underflow and out-of-bounds heap reads and writes, enabling worker crashes, memory disclosure, or unauthenticated remote code execution with worker-process privileges—not automatic root access. The content identifies NGINX Open Source 1.9.5–1.31.8 and multiple NGINX Plus branches as affected. Rapid7 released public RCE exploit code with substantial traffic and platform requirements. No confirmed real-world exploitation was reported as of November 19, 2026. Open Source fixes are 1.30.7 and 1.31.9; listed Plus fixes include 37.3.0.1 and 37.0.8.1. Temporarily disabling HTTP/2 blocks this vulnerability’s attack path when immediate patching is impossible.Read more ↗hackreadNews · Nov 19, 2026F5 Patches Two NGINX HTTP/2 Vulnerabilities, One Dating Back to 2015An integer underflow in NGINX HTTP/2 flow-control accounting that can cause an out-of-bounds memory operation and unauthenticated remote code execution. It affects versions dating back to 1.9.5 and requires HTTP/2 to be enabled. Researchers demonstrated remote code execution on official NGINX 1.31.7 and 1.31.8 builds. Fixes are available in NGINX Open Source 1.30.7 and 1.31.9 and applicable NGINX Plus releases. Temporarily disabling HTTP/2 is a workaround.Read more ↗socprime blogNews · Nov 19, 2026CVE-2026-123633: Critical NGINX HTTP/2 RCEA separate NGINX vulnerability disclosed alongside CVE-2026-123633 in the November 18, 2026 security release. It can affect HTTP/2-enabled instances serving ordinary static content, unlike the reverse-proxy-specific primary vulnerability. Patches exist, but NGINX Plus requires newer releases than those sufficient to fix CVE-2026-123633. The reference does not specify its underlying flaw, exact fixed versions, or exploitation status.Read more ↗
+29 more in the timeline. Sign up to see them
Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Mallory platform

The version that knows your environment.

This page is what’s public. Mallory adds the parts that aren’t: which of your assets are affected, which adversaries are exploiting it right now, and which detections to deploy tonight.
Exposure mappingQuery your assets running an affected version, and investigate the blast radius.
Threat actor evidenceEvery report linking this CVE to a named adversary.
Associated malwareMalware families linked to this CVE, with evidence and IOCs.
Detection signaturesYARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Vendor-by-vendor mappingCross-references every affected SKU, including bundled OEM variants.
Social activity161Community discussion across Reddit, Mastodon, and other social sources.