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.
8 min read
CVE-2026-126187 Hits React Server Components and Next.js: How Smuggled Flight Rows Lead to RCE
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-126187at CVSS 4.0 9.5 (Critical) with vectorCVSS: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-126187is 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-r5xrtargeting Next.jsuse cacheandCVE-2026-126187-poc) were published on November 12, 2026, demonstrating single-request unauthenticated RCE against19.2.8and confirming immunity on19.2.9/ Next.js16.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 of19.2.9's exact-size buffer copying versus19.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.
5. How is CVE-2026-126187 related to CVE-2025-55182?
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
- GitHub Advisory Database: React: Unauthenticated Remote Code Execution in React Server Components (
CVE-2026-126187/GHSA-xqc2-xf4c-x3h3) — Published November 10–11, 2026. - AhnLab ASEC: React Product Security Update Advisory (
CVE-2026-126187) — Published November 13, 2026. - StepSecurity:
CVE-2026-126187: React Server Components Flaw Lets Attackers Execute Code Through Smuggled Flight Rows — Published November 10, 2026 (updated Nov 12, 2026). - GitHub
rudSarkar/GHSA-673q-mjm6-r5xr: Next.jsuse cache/ React Flight Root-Cause Analysis — Published November 12, 2026.