Vulnerability

CVE-2026-126187 Hits React Server Components and Next.js: How Smuggled Flight Rows Lead to RCE

A CVSS 9.5 unauthenticated RCE in React Server Components (CVE-2026-126187) lets attackers smuggle Flight protocol rows when responses share an ArrayBuffer. Get affected React 19 and Next.js 16 versions, audit commands, and defensive TypeScript mitigations.

By 0xScorPionSon

8 min read

CVE-2026-126187 Hits React Server Components and Next.js: How Smuggled Flight Rows Lead to RCE

CVE-2026-126187 React Server Components Flight RCE Infographic

Executive Summary

On November 10, 2026, the React team—working through GitHub's CVE Numbering Authority (CNA)—disclosed CVE-2026-126187 (GHSA-xqc2-xf4c-x3h3), a CVSS 4.0 9.5 (Critical) unauthenticated remote code execution (RCE) vulnerability in the React Server Components (RSC) Flight transport protocol (CWE-502: Deserialization of Untrusted Data). The flaw affects three core bundler packages—react-server-dom-webpack, react-server-dom-parcel, and react-server-dom-turbopack—across React 19.0.x, 19.1.x, 19.2.x, and 19.3.0, as well as downstream frameworks such as Next.js 16.0.0 through 16.4.0 (GHSA-673q-mjm6-r5xr).

This is the second critical Flight-protocol RCE disclosed in twelve months, following CVE-2025-55182 (CVSS 10.0) in December 2025. While the official advisory notes that exploitation requires specific runtime preconditions—responses transporting multiple typed-array views over a shared ArrayBuffer alongside an attacker-controlled value—multiple public Dockerized proof-of-concept repositories and technical reconstructions were published between November 11 and November 13, 2026.

Engineering teams running Server-Side Rendering (SSR), edge rendering, or Next.js use cache functions should immediately audit lockfiles, upgrade to React 19.0.9, 19.1.10, 19.2.9, or 19.3.1 (and Next.js 16.4.1+), and verify that transitive dependencies are rebuilt and redeployed. Client-only React applications without an RSC-capable server or bundler plugin are not affected.


Affected and Patched Version Matrix

Per the GitHub Advisory (GHSA-xqc2-xf4c-x3h3), AhnLab ASEC Advisory, and StepSecurity, the following package versions are affected and fixed:

Package / Framework Affected Versions Patched Version(s) Exposure Scope
react-server-dom-webpack 19.0.0–19.0.8, 19.1.0–19.1.9, 19.2.0–19.2.8, 19.3.0 19.0.9, 19.1.10, 19.2.9, 19.3.1 RSC server writer & Flight client
react-server-dom-parcel 19.0.0–19.0.8, 19.1.0–19.1.9, 19.2.0–19.2.8, 19.3.0 19.0.9, 19.1.10, 19.2.9, 19.3.1 Parcel RSC bundler integration
react-server-dom-turbopack 19.0.0–19.0.8, 19.1.0–19.1.9, 19.2.0–19.2.8, 19.3.0 19.0.9, 19.1.10, 19.2.9, 19.3.1 Turbopack RSC bundler integration
Next.js (GHSA-673q-mjm6-r5xr) >= 16.0.0, < 16.4.1 16.4.1+ use cache / vendored Flight runtime

Technical Mechanics and Architecture

How the Flight Wire Protocol Desynchronizes

React Server Components stream UI trees and serialized data as length-delimited and newline-delimited Flight rows. Text rows carry JSON metadata or module references (I rows, which resolve via __webpack_require__(id) in webpack builds), while binary rows (o for Uint8Array) declare an exact hexadecimal byte count in the row header followed by raw binary payload bytes without a trailing newline.

As documented in StepSecurity's reconstruction of React pull requests #37842 through #37846, the vulnerability stems from a zero-copy optimization paired with silent zero-length chunk skipping:

+-----------------------------------------------------------------------------+
|       CVE-2026-126187: SHARED ARRAYBUFFER DETACH & FLIGHT DESYNC            |
+-----------------------------------------------------------------------------+
|                                                                             |
|  [ VULNERABLE WRITER (react-server-dom-* 19.2.8) ]                          |
|   Shared 8192B ArrayBuffer -> View A (4096B) + View B (4096B)               |
|     1. View A > 2048B: queued zero-copy; consumer detaches ArrayBuffer      |
|     2. View B.byteLength silently becomes 0 AFTER header is queued          |
|     3. Header emitted:  "3:o1000," (promises 4096 bytes)                    |
|     4. Writer guard:    0 !== chunk.byteLength -> skips View B silently!    |
|                                                                             |
|  [ FLIGHT PARSER STATE MACHINE ]                                            |
|   Reads "3:o1000," -> expects 4096 bytes -> SWALLOWS subsequent rows!       |
|     +---> Parser resynchronizes inside attacker-controlled byte payload     |
|     +---> Parses smuggled row: 3:I["target-module",[], "*"]                 |
|     +---> Consumes chunk -> invokes __webpack_require__(id) -> RCE          |
|                                                                             |
|  [ PATCHED WRITER (19.2.9 / 19.3.1) ]                                       |
|   Copies large typed-array views into exact-size buffers (4096B == 4096B)   |
|   before crossing the stream boundary -> no starved headers emitted         |
+-----------------------------------------------------------------------------+

Specifically, when the Flight writer serializes a typed array larger than 2,048 bytes in 19.2.8, it passes a live view over the application's underlying ArrayBuffer (byteLength=4096 bufferByteLength=8192) directly to the stream destination. If a downstream consumer—such as a fetch() body, a WHATWG ReadableStream BYOB reader, or an edge-runtime transfer boundary—takes ownership and detaches the shared ArrayBuffer, the second view's byteLength drops to 0. Because the Flight writer queues the header string (id:o1000,) and the binary view as two separate entries, its 0 !== chunk.byteLength guard drops the payload bytes silently while leaving the 4096-byte promise on the wire.

On the receiving end, the Flight parser trusts the declared byte count. It swallows subsequent legitimate rows as binary data, resynchronizes inside attacker-influenced bytes, and can interpret a smuggled module row (I) as a valid server reference.

Defensive Coding Pattern: Isolating Typed-Array Views Before RSC Serialization

If you cannot immediately upgrade your framework or react-server-dom-* packages, React's own fix guidance provides a clean defensive invariant: never transport multiple views over a single shared ArrayBuffer across an RSC serialization boundary. Always copy each view into an independent, exact-size buffer before returning it from a Server Component, Server Action, or use cache function:

// Defensive boundary wrapper for RSC / Next.js Server Actions & `use cache`
export function cloneTypedArrayForRSC<T extends ArrayBufferView>(view: T): Uint8Array {
  // Creates a detached, exact-length copy so downstream stream transfers
  // cannot invalidate sibling views over a shared ArrayBuffer.
  return new Uint8Array(
    view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength)
  );
}

// Safe usage when returning binary slices from a Server Component or cached loader
export async function getSafeBinaryChunks(sharedBuffer: ArrayBuffer) {
  const firstSlice = new Uint8Array(sharedBuffer, 0, 4096);
  const secondSlice = new Uint8Array(sharedBuffer, 4096, 4096);

  return {
    primary: cloneTypedArrayForRSC(firstSlice),
    secondary: cloneTypedArrayForRSC(secondSlice),
  };
}

Defensive Edge Guard: Detecting Starved Flight Binary Rows

Because the patched Flight parser still assumes honest framing if a future bug or custom wrapper emits a starved header, StepSecurity recommends monitoring rendered Flight responses at proxies or CDNs for length-versus-bytecount mismatches and abrupt "Connection closed" client errors after responses carrying large typed arrays.


Evidence: Severity, Exploitation Status, and Scope

  • Severity & Scoring: GitHub's CNA rates CVE-2026-126187 at CVSS 4.0 9.5 (Critical) with vector CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:N (GHSA-xqc2-xf4c-x3h3). AT:P (Attack Requirements: Present) reflects the precondition that a vulnerable endpoint must transport multiple typed arrays over a shared buffer alongside attacker-controlled data.
  • EPSS & KEV Status: As of November 11–13, 2026, FIRST's Exploit Prediction Scoring System (EPSS) stands at 1.763% (78th percentile) on the GitHub Advisory page, and CVE-2026-126187 is not listed in CISA's Known Exploited Vulnerabilities (KEV) catalog, with no confirmed in-the-wild exploitation reported by React or CISA at this time.
  • Proof-of-Concept Availability: Multiple public Dockerized PoC repositories (including GHSA-673q-mjm6-r5xr targeting Next.js use cache and CVE-2026-126187-poc) were published on November 12, 2026, demonstrating single-request unauthenticated RCE against 19.2.8 and confirming immunity on 19.2.9 / Next.js 16.4.1.
  • Confidence Level: High on affected/patched versions, CVSS 4.0 vector, and root-cause mechanics (corroborated across GitHub Advisory GHSA-xqc2-xf4c-x3h3, AhnLab ASEC, and StepSecurity's lab verification). Benchmark Note: No standardized public performance benchmark measuring the CPU/memory overhead of 19.2.9's exact-size buffer copying versus 19.2.8's zero-copy path has been published by the React team.

Hardening & Remediation Playbook

Step 1: Audit Resolved Transitive Dependencies Across All Lockfiles

Because react-server-dom-* packages are almost always pulled in transitively by Next.js, React Router framework mode, or Vite RSC plugins, inspect resolved lockfiles—not just package.json:

# Inspect resolved React Flight packages in the current workspace
npm ls react-server-dom-webpack react-server-dom-parcel react-server-dom-turbopack next

# Scan lockfiles across repositories for affected 19.x / Next.js 16.x builds
grep -nE '"react-server-dom-(webpack|parcel|turbopack)"|"next"' package-lock.json pnpm-lock.yaml yarn.lock 2>/dev/null

Step 2: Upgrade to Patched React and Next.js Releases

Upgrade your framework or direct Flight packages to the fixed versions and rebuild and redeploy all SSR and edge container images:

# For Next.js 16.x deployments (bundles fixed Flight runtime)
npm install next@^16.4.1

# For direct React 19.2.x RSC consumers
npm install react@19.2.9 react-dom@19.2.9 react-server-dom-webpack@19.2.9

Ensure package-lock.json, pnpm-lock.yaml, or yarn.lock resolves to 19.0.9, 19.1.10, 19.2.9, or 19.3.1 (and next >= 16.4.1).

Step 3: Enforce Registry Policy Controls in CI/CD

Configure your private npm registry or artifact firewall (such as npm overrides or StepSecurity Secure Registry's Custom Block List) to block future installs of the affected ranges (19.0.0–19.0.8, 19.1.0–19.1.9, 19.2.0–19.2.8, 19.3.0) while permitting 19.0.9, 19.1.10, 19.2.9, and 19.3.1.

Step 4: Hunt for Flight Corruption and Post-Exploitation Signals

Search application, edge proxy, and endpoint logs for anomalous Flight responses and unexpected child processes spawned by Node.js SSR workers:

-- Example log hunt for SSR/edge worker crashes or Flight stream anomalies
SELECT
  timestamp,
  service_name,
  host,
  status_code,
  request_path,
  error_message
FROM app_edge_logs
WHERE timestamp >= NOW() - INTERVAL '7 days'
  AND (
    error_message LIKE '%Connection closed%'
    OR error_message LIKE '%__webpack_require__%'
    OR (request_path LIKE '%/_next/%' AND status_code >= 500)
  )
ORDER BY timestamp DESC;

On runtime hosts and containers, verify that node / next-server processes have not spawned unexpected shells (sh, bash, curl, wget) and enforce strict outbound network egress controls on SSR and edge runtimes.

Step 5: Rollback Notes

If upgrading Next.js to 16.4.1 or React to 19.2.9 / 19.3.1 introduces an unexpected bundler or caching regression, do not roll back to an unpatched 19.2.8 / 16.4.0 build in production without first auditing every Server Component, Server Action, and use cache handler to ensure zero typed arrays (Uint8Array, ArrayBuffer views) are serialized over RSC responses, and applying the cloneTypedArrayForRSC() copy wrapper above.


Frequently Asked Questions

1. Is my client-side React 19 Single-Page Application (SPA) vulnerable to CVE-2026-126187?

No. Per the official GitHub advisory, if your React application does not use a server and does not use a framework, bundler, or bundler plugin that supports React Server Components (RSC), it is not affected.

2. Why does CVE-2026-126187 have a CVSS 4.0 score of 9.5 if the preconditions are rare?

Because when the preconditions are met—an RSC response carrying multiple typed-array views over a shared ArrayBuffer alongside attacker-controlled bytes—an unauthenticated remote attacker can execute arbitrary modules on the server without user interaction (AV:N/AC:L/AT:P/PR:N/UI:N).

3. Does Next.js need to be upgraded if we don't import react-server-dom-webpack directly?

Yes. Next.js vendors and bundles the React Flight runtime internally. Next.js 16.0.0 through 16.4.0 (including use cache paths) is affected and must be upgraded to 16.4.1 or later.

4. Can a Web Application Firewall (WAF) alone block CVE-2026-126187?

No. The corruption occurs inside the serialized Flight response stream and depends on ArrayBuffer transfer semantics in the server/edge runtime. Upgrading to patched React/Next.js versions—or copying typed-array views before RSC serialization—is required.

Both vulnerabilities affect the React Server Components Flight protocol (CWE-502), marking the second critical Flight RCE in twelve months. CVE-2025-55182 (CVSS 10.0) was patched in December 2025, while CVE-2026-126187 (CVSS 9.5) was patched on November 10, 2026.


Sources

More on Vulnerability

Tell us what is not working

A thirty-minute call, no deck and no obligation. You will leave with a straight answer about whether this is worth building - including if that answer is no.

Start a project

Direct line

hello@codebumble.net
Dhaka, Bangladesh  :   local timeCalls in English or Bangla