A React Server Components response can turn attacker-influenced data into a module load when shared typed-array buffers lose bytes in transit. React fixed CVE-2026-126187 on November 10 in three Flight packages used by server-rendered applications. An attacker needs no account, but the response must meet a rare combination of buffer and content conditions. Teams running an RSC-capable framework need to check the Flight package their deployed server actually uses.
Owais Shaikh’s StepSecurity research reproduced code execution from a real React render in a lab using a consumer that transfers a shared backing buffer. React’s advisory says the issue “only affects extremely rare cases where responses transport multiple typed arrays and an attacker-controlled value.” The consumer’s transfer behavior determines whether that combination occurs in a particular deployment.
A missing chunk shifts Flight rows
Flight carries a server-rendered UI as a stream of rows. Some rows declare a byte count for binary data; others tell the client how to resolve a module from the application’s bundle. In Shaikh’s analysis of the vulnerable 19.2.8 writer, two typed-array views share one backing ArrayBuffer. If a downstream consumer takes ownership of that buffer, a view can become detached. The writer then leaves a binary row’s length header in the response while silently dropping its bytes.
Shaikh’s build comparison locates the problem in the large-chunk path: above 2,048 bytes, the vulnerable writer sends a view of the application’s buffer instead of making a copy. His lab used two 4,096-byte views of one 8,192-byte buffer. In 19.2.8, an outgoing view still referenced that shared backing store; in 19.2.9, the outgoing store was exactly 4,096 bytes. The writer queues the length header and view separately. When transfer detaches the buffer, its zero-length-chunk handling skips the view without logging an error, even though the header is already on the wire.
The parser still consumes the promised byte count. It eats bytes belonging to later rows and resumes parsing at the wrong place, where attacker-influenced bytes can be interpreted as a module row. If the application consumes the resulting reference, React loads a module from its bundle. Shaikh demonstrated that chain against the vulnerable writer in a controlled render; honest framing kept the same data inert. His comparison with 19.2.9 found that the fixed writer copies large typed-array payloads into exact-size buffers before passing them to the destination.
That misplaced row has a second consequence in Shaikh’s parser test: a reference to a row whose header was swallowed can wait indefinitely, while the row that consumed the following bytes can still resolve as a typed array. Module references initialize only when the application consumes them. That is why a shifted stream can appear to make part of the UI hang while a reachable, misread module reference loads. The published fix restores the writer’s byte-count guarantee; the parser still relies on correctly framed input.
This is a conditional server-rendering exposure. The CVE Program record gives it a 9.5 CVSS v4 base score and lists unauthenticated remote code execution. React excludes client-only applications and apps without a framework, bundler or plugin that supports React Server Components. Shaikh’s reproduction is a lab result; investigate any suspicious production response against your own server telemetry before attributing an intrusion.
Three packages span four release lines
React lists react-server-dom-webpack, react-server-dom-parcel and react-server-dom-turbopack as affected. For each package, the vulnerable lines are 19.0.0–19.0.8, 19.1.0–19.1.9, 19.2.0–19.2.8, and 19.3.0. The first fixed releases are 19.0.9, 19.1.10, 19.2.9, and 19.3.1, respectively. Move to the fixed release for the line you run, or a later fixed release supported by your framework.
Frameworks can bring these packages in transitively. In an RSC application’s build environment, run the defensive inventory command npm ls react-server-dom-webpack react-server-dom-parcel react-server-dom-turbopack and inspect the resolved lockfile and bundled package versions. For framework-managed dependencies, upgrade the framework through its supported security release, then rebuild and redeploy the server or edge bundle. A changed dependency declaration alone leaves an older running bundle in service.
Shaikh names Next.js, React Router framework mode and Vite RSC plugins as examples of integrations that may pull in the Flight packages. Compare resolved versions in the lockfile used by each build, including npm, Yarn, pnpm or Bun projects, then identify which built server or edge artifact is running. For an affected build, trace whether the RSC response carries multiple views over one ArrayBuffer and whether the consumer transfers that store. The advisory’s rare precondition is about that response path, so a dependency match tells you where to investigate and patch first.
Check responses and deployed builds
If you retain Flight response captures, compare a binary row’s declared byte length with the bytes actually available before the next row. Shaikh also names client Connection closed errors after responses containing large typed arrays as a lead for triage. A truncated response can have other causes, so correlate those signals with the affected deployed version and the application’s response path. If response bodies are unavailable, use the deployed-version inventory to scope exposure and treat client errors as leads for further investigation.
For a post-upgrade check, capture a benign RSC response that carries multiple typed-array views through the application’s normal consumer and compare each declared binary length with its delivered bytes. In Shaikh’s patched 19.2.9 render, every binary row received the bytes it promised. Use the same destination path your deployment actually runs; that response-level result complements the resolved-version check and tests the framing behavior in the exercised path.
Confirm the running Flight build
Take ownership of the deployed RSC version: locate the three Flight packages in server-rendered apps, upgrade through the framework where appropriate, and verify that the rebuilt production bundle resolves to 19.0.9, 19.1.10, 19.2.9, or 19.3.1 on its respective line. Until an upgrade is deployed, avoid transporting multiple views of a shared ArrayBuffer in a Flight response; copying a view before rendering is the stopgap Shaikh describes. Investigate response anomalies that predate the redeployment on their own timeline.