critical

CVE

CVE-2026-123864, CVE-2026-123866, CVE-2026-123874, CVE-2026-123872, CVE-2026-123863, CVE-2026-123865, CVE-2026-126051, CVE-2026-123828, CVE-2026-123867, CVE-2026-123868, CVE-2026-123871, CVE-2026-123875, CVE-2026-123877, CVE-2026-123829, CVE-2026-123862, CVE-2026-106071, CVE-2026-123873, CVE-2026-119618, CVE-2026-106023, CVE-2026-109163, CVE-2026-121737, CVE-2026-119236, CVE-2026-119233, CVE-2026-119234, CVE-2026-119235, CVE-2026-119237, CVE-2026-119723

CWE

CWE-416, CWE-125, CWE-362, CWE-787, CWE-287, CWE-295, CWE-400, CWE-476, CWE-617

Affected Surface

  • Node.js runtime `22.x < 22.23.5`, `24.x < 24.22.3`, and `26.x < 26.13.1` (and all End-of-Life release lines) (`CVE-2026-123864`, `CVE-2026-123866`, `CVE-2026-123874`, `CVE-2026-123872`, `CVE-2026-123863`, `CVE-2026-123865`, `CVE-2026-126051`, `CVE-2026-123828`, `CVE-2026-123867`, `CVE-2026-123868`, `CVE-2026-123871`, `CVE-2026-123875`, `CVE-2026-123877`, `CVE-2026-123829`, `CVE-2026-123862`, `CVE-2026-106071`, and `CVE-2026-123873`, plus bundled `llhttp 9.4.4`, `undici 8.12.4`, `sqlite 3.54.1`, and `brotli 1.2.1`)
  • Apache HTTP Server (`httpd`) versions `2.4.55` through `2.4.70` and `icing/mod_h2` versions `2.0.8` through `2.0.42` (`CVE-2026-119618` Critical `mod_http2` RCE, fixed in `httpd 2.4.71`), `httpd` `2.4.30` through `2.4.70` (`CVE-2026-106023` Important `mod_md` NULL pointer dereference), and `httpd` `2.4.69` through `2.4.70` (`CVE-2026-109163` `mod_vhost_alias` stack overwrite)
  • Meta `proxygen` and `mvfst` versions `< v2026.11.09.00` (`CVE-2026-121737` HTTP/1.1 pipelined stream use-after-free, `CVE-2026-119236` QUIC Handshake `CRYPTO` frame memory exhaustion, and `CVE-2026-119233`, `119234`, `119235`, `119237`) and `HHVM` prior to commit `23c061f4e804` (`CVE-2026-119723` query/form nested-array crash)

TL;DR

On 11 November 2026 (12:19 to 17:19 UTC), the Node.js project, the Apache HTTP Server team, and Meta disclosed 26 vulnerabilities across HTTP/1.1, HTTP/2, HTTP/3, and TLS server implementations:

  1. Node.js 26.13.1, 24.22.3, and 22.23.5 patch 16 CVEs (including 7 High-severity HTTP/2 and TLS flaws):
    • Cross-connection heap and private-key disclosure in HTTPS (CVE-2026-123864, High, 22.x / 24.x / 26.x) and HTTP/2 (CVE-2026-123866, High, 22.x / 24.x / 26.x): In src/crypto/crypto_tls.cc, calling TLSWrap::DoWrite() with a zero-length buffer invoked ClearOut() synchronously even when called from JavaScript executing inside llhttp’s on_body callback. ClearOut() decrypted the next TLS record and re-entered llhttp_execute() while the outer parser frame was still mid-body, triggering a use-after-free and out-of-bounds heap read that copied other connections’ memory (including TLS private keys and other users’ requests) into the current request body (CVE-2026-123864, commit 940cae5c3346). In src/node_http2.cc (CVE-2026-123866, commit 7df134e2ceaf), tearing down an HTTP/2 stream while a socket write was backpressured freed the stream’s response buffer while outgoing_buffers_ still held a raw slice pointer (uv_buf_init), writing freed heap memory (including other connections’ response buffers) directly to the peer socket.
    • HTTP/2 respondWithFile() use-after-free (CVE-2026-123874, High, 24.x / 26.x), session.altsvc() 1-byte heap overflow (CVE-2026-123828, Medium), and remote process aborts (CVE-2026-123863 High, CVE-2026-123865 High, CVE-2026-126051 High, CVE-2026-123875 Medium): Resetting a stream.respondWithFile() or stream.respondWithFD() stream while a partial write slice was queued on the socket freed the Http2Stream (req_wrap was nullptr on non-final slices), causing the write-completion callback to make a virtual call through a freed Http2Stream (CVE-2026-123874, commit 9183db64fe78). Meanwhile, removing a stream from streams_ without calling ClearHeaders() tripped CHECK_EQ(current_nghttp2_memory_, 0) in ~Http2Session() (CVE-2026-123863, incomplete fix for CVE-2024-27983), triggering a protocol error after GOAWAY(NO_ERROR) leaked sessions in CLOSE_WAIT (CVE-2026-123865, incomplete fix for CVE-2026-48937), and passing a long :authority header to session.altsvc() wrote a null byte 1 byte past the MaybeStackBuffer<uint8_t> allocation (CVE-2026-123828).
    • Per-host mTLS and https.Agent certificate-validation bypasses (CVE-2026-123872 High, CVE-2026-123867 Medium, and CVE-2026-123877 Medium): Clients could switch the SNI servername during TLS 1.2 renegotiation, TLS 1.3 HelloRetryRequest, or session resumption to carry a client certificate validated under a permissive host onto a stricter protected host (CVE-2026-123872); server.addContext(host, { ca }) silently kept the default client CA whenever the SNI context omitted a server certificate (CVE-2026-123867); and https.Agent.prototype.getName() produced the same session-cache key for { ca: [] } and an omitted ca option (CVE-2026-123877).
  2. Apache HTTP Server 2.4.71 (CVE-2026-119618 Critical RCE, CVE-2026-106023 Important, CVE-2026-109163 Low): In modules/http2/h2_request.c (2.4.55 through 2.4.70 and icing/mod_h2 2.0.8 through 2.0.42), when an HTTP/2 request carried a Content-Type header and ended immediately with END_STREAM (eos) and no Content-Length, assign_headers() called apr_table_setn(req->headers, "Content-Length", "0") on the shared const h2_request *req structure rather than the per-request r->headers_in table (commit 824beab9b942). Because apr_table_t is not thread-safe and backed by the connection/stream pool, concurrent access corrupted the APR pool/heap and enabled remote code execution.
  3. Meta proxygen & mvfst v2026.11.09.00 (CVE-2026-121737, CVE-2026-119233 to 119237) and HHVM (CVE-2026-119723): proxygen freed a pipelined HTTP/1.1 stream during write-timeout reset and then continued using it (CVE-2026-121737), mvfst retained uncounted Handshake-level CRYPTO frames when a client withheld HANDSHAKE_DONE ACKs (CVE-2026-119236), and HHVM dereferenced an uncreated nested array when symtable->append() failed during query/form parameter parsing (CVE-2026-119723).

What to do now: Upgrade Node.js to 26.13.1, 24.22.3, or 22.23.5; upgrade Apache HTTP Server to 2.4.71 (or patch mod_http2 / mod_h2 with 824beab9b942); and update Meta proxygen and mvfst to >= v2026.11.09.00 and HHVM past commit 23c061f4e804.

Affected runtimes and servers

EcosystemProduct / PackageCVE IDsSeverityAffected versionsFixed version
Node.jsnode (https, http2, tls, zlib, Permission Model)CVE-2026-123864, CVE-2026-123866, CVE-2026-123872, CVE-2026-123865, CVE-2026-123867, CVE-2026-123871, CVE-2026-123875, CVE-2026-123877, CVE-2026-123829, CVE-2026-123862, CVE-2026-106071High / Medium / Low22.x < 22.23.5, 24.x < 24.22.3, 26.x < 26.13.122.23.5, 24.22.3, 26.13.1
Node.jsnode (http2, tls, v8.writeHeapSnapshot)CVE-2026-123874, CVE-2026-123863, CVE-2026-126051, CVE-2026-123828, CVE-2026-123868, CVE-2026-123873High / Medium / Low24.x < 24.22.3, 26.x < 26.13.124.22.3, 26.13.1
C / Web ServerApache HTTP Server (httpd) & icing/mod_h2CVE-2026-119618 (Critical RCE), CVE-2026-106023 (Important), CVE-2026-109163 (Low)Critical / Important / Lowhttpd 2.4.55..2.4.70 (119618), 2.4.30..2.4.70 (106023), 2.4.69..2.4.70 (109163); mod_h2 2.0.8..2.0.42httpd 2.4.71 (commits 824beab9b942, 1b47e95c61fb)
C++ / HTTP & QUICMeta proxygen and mvfstCVE-2026-121737, CVE-2026-119233, CVE-2026-119234, CVE-2026-119235, CVE-2026-119236, CVE-2026-119237High / Medium< v2026.11.09.00v2026.11.09.00 (daf245bba7fe, 7e5cff58e8cb)
C++ / RuntimeMeta HHVMCVE-2026-119723High (Pre-app remote crash DoS)< 23c061f4e804Commit 23c061f4e804

Technical analysis

1. Node.js CVE-2026-123864: how a zero-length TLS write inside on_body re-enters llhttp_execute() and leaks heap memory

In Node.js HTTPS servers, incoming ciphertext is decrypted by TLSWrap::Cycle() (ClearOut()), which emits plaintext chunks to the attached HTTP parser listener (Parser::OnStreamRead -> Parser::Execute -> llhttp_execute()). While llhttp_execute() is parsing an HTTP request body, it invokes the on_body callback (Parser::OnBody), which synchronously runs JavaScript data listeners on the IncomingMessage stream.

In src/crypto/crypto_tls.cc prior to commit 940cae5c3346, TLSWrap::DoWrite() contained a special case for zero-byte writes (length == 0) that called ClearOut() directly without checking whether TLSWrap was already inside Cycle():

--- a/src/crypto/crypto_tls.cc
+++ b/src/crypto/crypto_tls.cc
@@ -1123,7 +1123,11 @@ int TLSWrap::DoWrite(WriteWrap* w,
   // WriteWrap was accepted by the stream, or that we call Done() on it.
   if (length == 0) {
     Debug(this, "Empty write");
-    ClearOut();
+    // When the write comes from JS running inside Cycle(), for example from a
+    // stream listener in ClearOut(), the cycle reads and encrypts any pending
+    // data once that JS returns. Reading here would hand the next record to
+    // the listener while it is still processing the current one.
+    if (cycle_depth_ == 0) ClearOut();
     if (BIO_pending(enc_out_) == 0) {

Meanwhile, in src/node_http_parser.cc, Parser::Execute() and Parser::OnStreamRead() overwrote current_buffer_data_ and current_buffer_len_ with nullptr and 0 on exit rather than restoring the outer frame’s buffer pointer:

  1. An HTTPS handler calls res.flushHeaders() before the request body finishes, and later calls res.end(chunk) inside a body data listener (which triggers a zero-length TLS write alongside the chunk).
  2. TLSWrap::DoWrite() sees length == 0 and calls ClearOut() while the outer llhttp_execute() call is still paused inside on_body.
  3. ClearOut() decrypts the next queued TLS record and calls Parser::OnStreamRead(), which re-enters llhttp_execute() on the new buffer and then sets current_buffer_data_ = nullptr when the inner call returns.
  4. When execution unwinds back to the outer llhttp_execute() frame, pointer arithmetic between the outer buffer and current_buffer_data_ reads freed or unrelated heap memory (including TLS private keys and other clients’ HTTP requests) and appends it to the caller’s request body.

Commit 940cae5c3346 skips ClearOut() when cycle_depth_ > 0, saves and restores outer_data and outer_len across nested Parser calls, and aborts parsing with HPE_REENTRANT_EXECUTE if a callback pointer no longer lies within current_buffer_data_.

2. Node.js HTTP/2 use-after-free flaws (CVE-2026-123866 and CVE-2026-123874) and TLS SNI mTLS bypasses (CVE-2026-123872, CVE-2026-123867, CVE-2026-123877)

Two High-severity use-after-free bugs in src/node_http2.cc stemmed from how Http2Session::OnSendData() sliced partial stream writes into outgoing_buffers_:

--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -2173,15 +2173,19 @@ int Http2Session::OnSendData(
     if (write.buf.len <= length) {
       // This write does not suffice by itself, so we can consume it completely.
       length -= write.buf.len;
+      write.stream = stream;
       session->PushOutgoingBuffer(std::move(write));
       stream->queue_.pop();
       continue;
     }
 
     // Slice off `length` bytes of the first write in the queue. Retain the
     // originating request until the slice is no longer used by the socket.
-    session->PushOutgoingBuffer(
-        NgHttp2StreamWrite { uv_buf_init(write.buf.base, length) });
+    session->PushOutgoingBuffer(
+        NgHttp2StreamWrite{nullptr,
+                           write.buffer_owner,
+                           stream,
+                           uv_buf_init(write.buf.base, length)});
     write.buf.base += length;
     write.buf.len -= length;
     break;
@@ -2279,8 +2283,7 @@ void Http2Session::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
 
 bool Http2Session::HasWritesOnSocketForStream(Http2Stream* stream) {
   for (const NgHttp2StreamWrite& wr : outgoing_buffers_) {
-    if (wr.req_wrap && WriteWrap::FromObject(wr.req_wrap)->stream() == stream)
-      return true;
+    if (wr.stream.get() == stream) return true;
   }
   return false;
 }
  • Response heap memory leaked to peer (CVE-2026-123866, commit 7df134e2ceaf): In Http2Stream::DoWrite(), req_wrap was attached only to the last buffer entry (i == nbufs - 1), and partial slices created in OnSendData() had req_wrap = nullptr. When a stream was reset (RST_STREAM or stream timeout) while a partial slice sat in outgoing_buffers_, the underlying buffer was freed before the TCP socket finished transmitting the slice, sending freed heap memory (including other connections’ responses) over the wire.
  • Http2Stream use-after-free on respondWithFile() (CVE-2026-123874, commit 9183db64fe78): HasWritesOnSocketForStream() checked wr.req_wrap && WriteWrap::FromObject(wr.req_wrap)->stream() == stream. Because partial slices had wr.req_wrap == nullptr, HasWritesOnSocketForStream() returned false while a slice was still queued on the socket, allowing Http2Stream to be freed and later dereferenced via a virtual call when the write completed.
  • Per-host mTLS and https.Agent bypasses (CVE-2026-123872, CVE-2026-123867, CVE-2026-123877): Commits 97b1357f0843, e750e1fa0258, and a8d62869496f (CVE-2026-123872) bind TLS session IDs to the SNI servername, reject SNI changes during TLS 1.2 renegotiation or TLS 1.3 HelloRetryRequest, and disable resumption for mTLS servers without a sessionIdContext. Commit 66e72ec604b2 (CVE-2026-123867) ensures TLSWrap::CertCbDone() calls w->SetCACerts(sc) even when an addContext(host, { ca }) SNI context has no separate server certificate. And commit fa61009dc1fa (CVE-2026-123877) replaces string concatenation in https.Agent.prototype.getName() with typed, length-prefixed getTlsOptionKey() encoding so ca: [] (which encodes as 'a0') no longer collides with ca: undefined ('').

3. Apache HTTP Server 2.4.71 (CVE-2026-119618): mod_http2 assign_headers() shared-table race to RCE

In Apache HTTP Server 2.4.55 through 2.4.70 (and icing/mod_h2 2.0.8 through 2.0.42), when an HTTP/2 stream is dispatched to a worker thread, h2_request_copy() creates the Apache request_rec *r and calls assign_headers(r, req, ...) in modules/http2/h2_request.c.

When a request carried a Content-Type header, omitted Content-Length, and set END_STREAM (req->eoh with no body), line 353 wrote "Content-Length": "0" into req->headers instead of r->headers_in:

--- a/modules/http2/h2_request.c
+++ b/modules/http2/h2_request.c
@@ -350,7 +350,7 @@ static void assign_headers(request_rec *r, const h2_request *req,
                 /* If we have a content-type, but already seen eos, no more
                  * data will come. Signal a zero content length explicitly.
                  */
-                apr_table_setn(req->headers, "Content-Length", "0");
+                apr_table_setn(r->headers_in, "Content-Length", "0");
             }
         }

Although req is declared const h2_request *req, req->headers is a non-const apr_table_t * allocated from the h2_mplx / stream pool on the main connection thread. Calling apr_table_setn(req->headers, ...) on the worker thread mutated req->headers (and triggered apr_array_push reallocations from the underlying apr_pool_t) concurrently with HTTP/2 multiplexer operations on the connection thread, causing heap corruption and remote code execution (commit 824beab9b942, found independently by Anthropic’s OSS Scanner ANT-2026-MAPKT6MZ and Anthony Weems & Simon Scannell of Google Cloud Vulnerability Research).

Detection and remediation

# 1. Check running Node.js and Apache HTTP Server versions
node -v 2>/dev/null || true
httpd -v 2>/dev/null || apache2 -v 2>/dev/null || true

# 2. Search Dockerfiles, CI workflows, and package manifests for vulnerable Node.js or httpd images
rg -n 'FROM\s+node:|node-version|httpd:2\.4\.' Dockerfile* .github/workflows/*.yml 2>/dev/null

# 3. Audit Node.js codebases for the high-risk HTTP/2 and mTLS patterns affected by CVE-2026-123864 / 123874 / 123867 / 123828
rg -n 'respondWithFile|respondWithFD|flushHeaders|addContext\s*\(|\.altsvc\s*\(' --glob '*.{js,ts,mjs,cjs}' 2>/dev/null
  1. Upgrade Node.js to 26.13.1, 24.22.3, or 22.23.5: If you run HTTPS servers that call res.flushHeaders() (CVE-2026-123864) or HTTP/2 servers that stream responses (CVE-2026-123866), treat exposed TLS private keys or session tokens in process memory as potentially disclosed and rotate them after upgrading.
  2. Upgrade Apache HTTP Server to 2.4.71: On servers where 2.4.71 cannot be deployed immediately and HTTP/2 is enabled (Protocols h2 h2c http/1.1), remove h2 / h2c from Protocols or disable mod_http2 until patched.
  3. Update Meta proxygen and mvfst to >= v2026.11.09.00 and HHVM past commit 23c061f4e804.

Timeline

  • 2026-09-29 to 2026-11-03: Researchers report CVE-2026-106023, CVE-2026-109163, and CVE-2026-119618 to the Apache HTTP Server security team.
  • 2026-11-04: Node.js publishes its November 2026 security release pre-alert on oss-security.
  • 2026-11-11 (12:19 to 15:17 UTC): Apache HTTP Server releases 2.4.71 and publishes CVE-2026-119618 (Critical mod_http2 RCE), CVE-2026-106023 (mod_md), and CVE-2026-109163 (mod_vhost_alias) on oss-security and NVD.
  • 2026-11-11 (16:44 to 17:19 UTC): Node.js tags and publishes v26.13.1, v24.22.3, and v22.23.5 fixing 16 CVEs (CVE-2026-123863 through CVE-2026-126051), and NVD publishes the Meta proxygen, mvfst, and HHVM advisories (CVE-2026-121737, CVE-2026-119233 to 119237, CVE-2026-119723).

From research to remediation

Check whether this pattern exists in your codebase

Turn this research into a remediation workflow. Use AI-native static analysis to find similar application vulnerabilities and generate review-ready fixes.

References