Automated Threat Modeling

Brief Summary: Node.js CVE-2026-123863, an Unauthenticated HTTP/2 Denial of Service via Reachable Assertion

A summary of CVE-2026-123863, a reachable assertion in Node.js HTTP/2 session teardown that lets an unauthenticated client abort the server. Includes the upstream regression-test PoC, patch details, and detection guidance.

CVE Analysis

9 min read

Gaurav Sarraf
Gaurav Sarraf

2026-11-11

Brief Summary: Node.js CVE-2026-123863, an Unauthenticated HTTP/2 Denial of Service via Reachable Assertion

Introduction

A single unauthenticated client can push a default Node.js HTTP/2 server into a native assertion failure and take the whole process down, over both TLS and cleartext h2c. For any exposed service running the affected release lines, that means a reachable denial of service with no credentials and no user interaction.

The issue, CVE-2026-123863, is a reachable assertion in Node.js HTTP/2 session teardown. It carries a CNA-supplied CVSS 3.0 score of 8.2 (CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:H) and is a variant of the earlier CVE-2024-27983 that the previous fix did not fully cover.

Technical Information

The vulnerability is classified as CWE-617, a reachable assertion. The crash point is explicit: CHECK_EQ(current_nghttp2_memory_, 0) inside ~Http2Session(). When that check fails, the process aborts. This is not a catchable JavaScript exception. It is a native CHECK in the HTTP/2 session destructor.

The root cause is an ownership and lifetime mismatch between two cleanup paths. When nghttp2 decodes header fields for a stream, each field holds a reference-counted nghttp2 buffer. Node stores these in the stream's current_headers_ list, and every byte nghttp2 allocates is counted in the session's current_nghttp2_memory_. The session destructor checks that this counter is back to zero.

The two paths that diverge:

  1. If a peer sends more header fields than maxHeaderListPairs (128 by default), the stream is reset. The fields it already accepted stay in current_headers_. Http2Session::RemoveStream() removed the stream from streams_ and lowered the session memory accounting, but it never released the headers themselves, so those nghttp2 buffers stayed allocated.
  2. A destroyed stream that still has a write queued on the socket is not detached. It can therefore be garbage-collected after its session. ~Http2Session() only cleans up streams still in streams_, and this stream had already been removed from it.

Put together, the session is destroyed while nghttp2 memory is still held by a stream it no longer tracks. The memory-accounting counter is nonzero, CHECK_EQ(current_nghttp2_memory_, 0) fails, and the process terminates. The advisory calls this a variant of CVE-2024-27983: the earlier fix only detached streams that the session was still tracking, leaving this removed-but-not-detached path uncovered.

Attack flow

Based on the briefing materials, the exploitation sequence is:

  1. Connect to a default HTTP/2 server (TLS or cleartext h2c) and send the HTTP/2 connection preface plus SETTINGS and WINDOW_UPDATE frames.
  2. Open many concurrent POST streams on a single connection using hand-crafted HEADERS frames.
  3. Send trailer HEADERS blocks that contain more fields than the server's maxHeaderListPairs (the default is 128). This resets the streams while already-accepted fields remain in current_headers_, still holding nghttp2 buffers.
  4. Arrange for the server handler to respond before the request body has ended (typical behaviour), keeping response writes pending on the socket so the streams are kept alive and not detached.
  5. Tear the connection down abruptly. On a vulnerable build, a removed stream is collected after its session, and the destructor assertion fails, aborting the process.

The CVSS vector records network reachability, low attack complexity, no privileges, no user interaction, unchanged scope, no confidentiality impact, low integrity impact, and high availability impact. The evidenced outcome is process termination and service unavailability.

Proof of Concept

A public, runnable proof-of-concept exists as the upstream Node.js regression test that ships with the fix. It should be characterized as a vendor regression-test PoC rather than a weaponized standalone exploit. NVD lists only the OpenJS/Node.js advisories with no separate PoC-tagged reference.

The test, test/parallel/test-http2-removed-stream-headers-outlive-session.js (87 lines, run with --expose-gc), is a complete self-contained reproducer. It stands up a default http2.createServer(), connects a raw net socket acting as a malicious HTTP/2 client, sends the connection preface plus SETTINGS and WINDOW_UPDATE frames, opens 80 concurrent streams (kStreams = 80) with hand-crafted HEADERS frames, then sends trailer HEADERS blocks containing 200 fields each (exceeding the default maxHeaderListPairs of 128) so the streams are reset while still holding nghttp2 header buffers. The server handler responds with a 100 KB body before the request body ends, keeping writes pending, and the client then issues resetAndDestroy(). The test forces garbage collection (repeated globalThis.gc()) so a removed stream is collected after its session, which on a vulnerable build triggers the assertion and aborts the process.

The credited reporter is Chris Rohlf (in collaboration with Claude and Anthropic Research), the fix is by Matteo Collina, and the issue references HackerOne report 4150893.

Key portion of the reproducer, from the fetched commit diff:

// Flags: --expose-gc 'use strict'; const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); const http2 = require('http2'); const net = require('net'); const { setTimeout: sleep } = require('timers/promises'); const kStreams = 80; function frame(type, flags, id, payload = Buffer.alloc(0)) { const header = Buffer.alloc(9); header.writeUIntBE(payload.length, 0, 3); header[3] = type; header[4] = flags; header.writeUInt32BE(id, 5); return Buffer.concat([header, payload]); } // :method POST, :scheme http, :path /, :authority localhost const requestHeaders = Buffer.from([ 0x83, 0x86, 0x84, 0x01, 0x09, ...Buffer.from('localhost'), ]); // More trailer fields than the default maxHeaderListPairs (128). const trailers = Buffer.concat(Array.from({ length: 200 }, (_, i) => { const name = `x-${i}`; return Buffer.from([0x00, name.length, ...Buffer.from(name), 0x01, 0x76]); }));

On unpatched builds this test aborts at the assertion. With the fix it completes normally.

Patch Information

Node.js fixed CVE-2026-123863 in the November 11, 2026 security releases. The fix is a single commit titled "http2: release headers when a stream is removed", written by Matteo Collina and reviewed by Robert Nagy and Tim Perry. It was developed privately as nodejs-private/node-private#1026 and backported to each release line:

Release lineFixed versionCommit
26.xv26.13.10ff0cf6749
24.xv24.22.3ff8938913b
22.xv22.23.59bce421783

The advisory and NVD record list only 24.x and 26.x as affected (NVD: 24.0.0 up to but not including 24.22.3, and 25.0.0 up to but not including 26.13.1). The 22.x release ships the same change, so 22.x gets the hardening as well.

The patch adds eight lines to src/node_http2.cc, all of them calls to stream->ClearHeaders() plus comments, in two places. Here is the v26.x diff from commit 0ff0cf6749:

@@ -637,6 +637,9 @@ Http2Session::~Http2Session() { // Ensure that all `Http2Stream` instances and the memory they hold // on to are destroyed before the nghttp2 session is. for (const auto& [id, stream] : streams_) { + // Detach() only frees the stream if nothing else holds a strong + // reference to it. + stream->ClearHeaders(); stream->Detach(); } streams_.clear(); @@ -946,6 +949,11 @@ BaseObjectPtr Http2Session::RemoveStream(int32_t id) { stream = FindStream(id); if (stream) { streams_.erase(id); + // The stream can outlive the session, for example while one of its writes + // is still on the socket. Headers that were not passed to JS, such as an + // oversized block that caused the stream to be reset, hold nghttp2 memory + // that has to be released before the session is. + stream->ClearHeaders(); if (stream->current_headers_length_ > 0) { DecrementCurrentSessionMemory(stream->current_headers_length_); stream->current_headers_length_ = 0;

Each change covers one way a stream can escape cleanup:

  • In RemoveStream(): the main fix. Once a stream leaves the session's stream set, the session will never see it again. Clearing its headers at that point returns the nghttp2 buffers while the session and its memory counter still exist. The patch keeps the existing current_headers_length_ bookkeeping and adds the buffer release that was missing.
  • In ~Http2Session(): defence in depth. Detach() only frees a stream if nothing else holds a strong reference to it, and a pending socket write is exactly that kind of reference. Calling ClearHeaders() before Detach() means even streams still registered with the session, but kept alive elsewhere, give up their nghttp2 memory before the destructor checks the counter.

The key idea is ownership: header buffers allocated by nghttp2 belong to the session's lifetime, not the stream's, so they must be released whenever a stream leaves the session's control.

Detection Methods

No vendor-published signatures exist for CVE-2026-123863. There are no YARA, Sigma, Snort or Suricata rules and no network IoCs. The fix commit and advisory give defenders enough detail to build detections at three layers.

1. Exposure detection: find vulnerable runtimes

Treat any HTTP/2 server on 24.x below 24.22.3, or on 26.x below 26.13.1, as exposed. HTTP/2 over TLS and cleartext h2c are both reachable, and the trigger works against a default http2 server.

  • On each host, container and CI runner, run node --version. A running process keeps the runtime it started with, so an upgraded binary on disk does not protect a long-running process until it restarts. Images pinned to older Node tags must be rebuilt.
  • For source builds or vendored runtimes, look for the fix commit, subject http2: release headers when a stream is removed (ff8938913b on 24.x, 0ff0cf6749 on 26.x). The patch adds stream->ClearHeaders() calls inside Http2Session::RemoveStream() and Http2Session::~Http2Session() in src/node_http2.cc. If those calls are missing, the build is unpatched.

2. Host-side detection: the assertion fingerprint

This is the most reliable sign that someone triggered the bug. Exploitation does not throw a catchable JavaScript error. It fails a native CHECK in the HTTP/2 session destructor and the process aborts. The advisory names the exact check: CHECK_EQ(current_nghttp2_memory_, 0) in ~Http2Session().

  • Send Node.js stderr, container logs, systemd journal output and crash reporters to your SIEM. Alert on the string current_nghttp2_memory_ together with Http2Session. Search for substrings rather than a full line, because the advisory does not publish the exact console output.
  • Join that alert with process supervisor signals: an abnormal, abort-style exit from a Node service serving HTTP/2, followed by a restart (Kubernetes restart counts, PM2/systemd restart events, crash-loop states). A crash loop on an internet-facing h2 service with this assertion string is a strong signal.
  • The same November 2026 release fixes other remotely triggerable crashes, including a NULL dereference on cancelled respondWithFile() downloads (CVE-2026-123875), an ALTSVC overflow abort (CVE-2026-123828), and an uncaught TLS exception (CVE-2026-126051). So "Node crashed" alone does not identify this CVE. The current_nghttp2_memory_ / ~Http2Session() text is what distinguishes CVE-2026-123863.

3. Network-side detection: what the trigger looks like

Wherever you can see decrypted HTTP/2 frames, such as an h2-terminating reverse proxy, load balancer or WAF, watch for:

  • HEADERS blocks (including trailers sent after the request) whose field count exceeds the server's maxHeaderListPairs. The default is 128; the regression test sends 200 trailer fields.
  • Many concurrent POST streams on one connection, where the client keeps them open and does not read the server's responses. Node's regression test pauses the client socket so large responses stay queued as pending writes.
  • The connection being torn down abruptly (a TCP reset) soon after, then the backend becoming unreachable or restarting.

These are behavioural heuristics, not a signature. Header-heavy clients and slow readers exist in legitimate traffic, so treat this as a correlation input that raises confidence when it lines up with the host-side assertion alert, not as a standalone verdict. Over TLS this telemetry is only available where TLS is terminated.

4. Validating your detections

The upstream regression test reproduces the frame sequence over loopback. On an isolated, unpatched staging build it lets you confirm your log pipeline catches the assertion string and that restart/crash-loop alerts fire. On a patched build it should finish without the abort, which also confirms remediation.

Affected Systems and Versions

The advisory narrative identifies the affected active release lines as 24.x (since 24.22.0) and 26.x (since 26.9.0). The NVD and CVE affected version metadata records 24.0.0 up to but not including 24.22.3, and 25.0.0 up to but not including 26.13.1.

Fixed versions:

  • Node.js 24.22.3
  • Node.js 26.13.1
  • Node.js 22.23.5 (ships the same hardening change)

There is a version range inconsistency worth treating conservatively. The narrative says 24.x is affected since 24.22.0 and 26.x since 26.9.0, while the affected product metadata begins at 24.0.0 and 25.0.0. The sources do not give one fully consistent answer for the earliest affected releases, particularly for the metadata range beginning at 25.0.0. If an installation is on a 25.x version, or on an earlier 24.x version whose status is uncertain, the published materials do not resolve that ambiguity. Obtain clarification from Node.js or the OpenJS CNA rather than assuming it is unaffected.

Vendor Security History

This issue is explicitly a variant of CVE-2024-27983, an earlier Node.js HTTP/2 assertion fix that only detached streams the session was still tracking, leaving the removed-but-not-detached path uncovered.

On the process side, the OpenJS Foundation 2025 annual report states the foundation launched an OpenJS CNA, completed security assessments for six projects, created threat models for two, and reduced Node.js security release steps from more than 20 to three per release line through automation. The Q2 2026 update reports a security release addressing 18 vulnerabilities and a streamlined process moving from 36 steps to seven. These are evidence of investment in disclosure and release processes, not proof that similar issues will not recur.

References

Detect & fix
what others miss

Works with
  • GitHub
  • GitLab
  • Bitbucket
  • Azure DevOps Services
  • Gerrit
  • CVS
  • Jira
  • Linear
  • Slack
  • Security Compass
Explore integrations
Security magnifying glass visualization