threat intelligence

GHSA-xqc2-xf4c-x3h3: Critical React Server Components Flaw Now Has Public Exploit Code, and Your Scanners May Not See It

November 11, 2026 CrowdSOC Team 10 min read
GHSA-xqc2-xf4c-x3h3: Critical React Server Components Flaw Now Has Public Exploit Code, and Your Scanners May Not See It
← back to insights
CrowdSOC Team · November 11, 2026

A critical flaw in React, the software toolkit behind a large share of modern websites and web applications, can let an attacker on the internet run their own code on a company's web servers, without logging in and without anyone clicking anything. A fix has been available since October 14. The problem is that most organisations may not know they need it: the flaw was never given a standard CVE number, so many of the automated security tools businesses rely on to flag dangerous software have had nothing to report. A clean security dashboard does not mean you are safe from this one.

The conditions needed to exploit it are narrow, and no attacks have been reported. But the clock has started: over the weekend of November 8 and 9, researchers published code that claims to exploit the flaw, along with ready-made test environments. React's last flaw of this kind, React2Shell, was exploited within hours of disclosure in December 2025. Organisations that have not yet patched should treat this as urgent.

The vulnerability is tracked only as GHSA-xqc2-xf4c-x3h3, a GitHub Security Advisory published by the React team on October 14, 2026. React rates it Critical, 9.5 out of 10 on CVSS v4. It affects the server-side packages that power React Server Components (RSC): react-server-dom-webpack, react-server-dom-turbopack, and react-server-dom-parcel. Next.js published its own companion advisory, GHSA-673q-mjm6-r5xr, and shipped a fixed release less than an hour after React.


Who is affected

The flaw lives on the server side of React, so a large part of the React world is not exposed at all.

Not affected:

  • Applications that render React only in the browser
  • Applications with no server-side React code
  • Applications that do not use a framework, bundler, or bundler plugin that supports React Server Components

Potentially affected:

  • Any application running an affected version of react-server-dom-webpack, react-server-dom-turbopack, or react-server-dom-parcel, whether through Next.js, another RSC framework, or a custom setup
  • Next.js 16.0.0 to 16.4.0 applications using the App Router with Cache Components enabled
Package Affected versions Fixed versions
react-server-dom-webpack 19.0.0 to 19.0.8, 19.1.0 to 19.1.9, 19.2.0 to 19.2.8, 19.3.0 19.0.9, 19.1.10, 19.2.9, 19.3.1
react-server-dom-turbopack Same as above Same as above
react-server-dom-parcel Same as above Same as above
next (GHSA-673q-mjm6-r5xr) 16.0.0 to 16.4.0 16.4.1

The patches section of React's advisory lists "19.0.09", which is a typo; the package tables confirm the fixed version is 19.0.9.


How the flaw works

React Server Components let React run parts of an application on the server and stream the results to the browser. The server and browser exchange that data using React's own wire format, called Flight. GHSA-xqc2-xf4c-x3h3 is a flaw in how the server side of Flight writes binary data into a response.

React's advisory is brief. It says crafted payloads aimed at RSC-capable frameworks can lead to remote code execution, but only in what it calls "extremely rare cases" where a response carries multiple typed arrays and an attacker-controlled value. Typed arrays (such as Uint8Array or Float32Array) are JavaScript's way of holding raw numeric and binary data.

React has not published a root cause or exploit steps, and the release notes for the fixed versions say only "Improve transport protocol", with no mention of security. Analysis of the patch by vulnerability database Mend and cloud security firm Upwind fills in the picture:

  • Shared buffers. Several typed arrays can be views onto the same underlying ArrayBuffer. The vulnerable response writer emitted typed arrays as views over the whole buffer and wrote large chunks without copying them.
  • Detached buffers and a framing desync. If that buffer is detached while the response is being written, the views suddenly report a length of zero. The old server skipped zero-length chunks, but the length headers it had already written still promised data. The stream and its framing fall out of step, and attacker-controlled data in the same response can end up being read where React expects its own structure.
  • Stream namespace collision. A separate fix gives streamed data its own namespace, because stream chunks were previously written under the same form-field keys as ordinary part IDs.

The patched server refuses to send a detached buffer and throws an error instead. Upwind notes that it has not reproduced code execution and that React has not explained how the desync becomes RCE. It also stresses that this is a JavaScript serialisation bug, not memory corruption, and not a deserialisation gadget chain like React2Shell.

What this means in Next.js

In Next.js, the vulnerable pattern maps to a specific feature: a use cache function that returns more than one typed array in an App Router application with Cache Components enabled. Netlify describes this as an unusual configuration not expected in normally functioning applications. Vercel's own guidance is blunter: there is no known workaround, and you should upgrade immediately even if your application does not have similar functions.

That advice is sound for two reasons. First, teams often do not know which cached functions return typed arrays, particularly when one is returned indirectly through a library or helper. Second, Cache Components is becoming more common; one developer write-up notes that new projects created with create-next-app 16.4 have it switched on by default.


Why your tools may have missed it

This is the part of the story that should concern security and risk leaders most. The vulnerability is critical, the fix is four weeks old, and many organisations' tooling has said nothing.

  • No CVE. Neither React's advisory nor the Next.js advisory has a CVE ID. Scanners, dashboards, and risk registers that key on CVEs have no record to match.
  • Missing from the main advisory feeds. As of November 8, GitHub's global advisory database had no entry for GHSA-xqc2-xf4c-x3h3, and developers reported on November 9 that both OSV and the GitHub Advisory Database still returned nothing for it. In the early days, neither advisory appeared in the npm feed that npm audit reads, so it stayed quiet. The Next.js advisory only entered the GitHub Advisory Database as a reviewed advisory on October 22, eight days after the fix.
  • Dependabot coverage is unclear. Dependabot draws from the GitHub Advisory Database. Security firm ThreatDefence reported on November 10 that Dependabot now lists both GHSA-xqc2-xf4c-x3h3 and GHSA-673q-mjm6-r5xr against lock files, but other reports from the previous day said the React advisory was still absent from the database. If you rely on Dependabot, confirm that it is actually raising alerts for the react-server-dom-* packages rather than assuming it is.
  • Next.js hides the vulnerable code. Next.js compiles its own copy of the RSC runtime into the next package. A dependency check for react-server-dom-webpack in a Next.js app can come back empty while the vulnerable code is present, and upgrading react and react-dom does not replace that bundled copy. Only a new next release does.
  • Not eligible for KEV. CISA's Known Exploited Vulnerabilities catalogue requires a CVE ID, so even if exploitation begins, this flaw cannot appear there in its current form. Organisations that use KEV as a trigger for emergency patching will get no signal from it. React2Shell, by contrast, was added to KEV on December 5, 2025, two days after disclosure.

The result is a critical vulnerability that is easy to fix and easy to overlook.


Severity

Source Score Notes
React (GHSA-xqc2-xf4c-x3h3) 9.5 Critical (CVSS v4) AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:N
Next.js (GHSA-673q-mjm6-r5xr) 9.5 Critical (CVSS v4) Shown as 10.0 (CVSS 3.1, CWE-502) in GitLab's advisory database
Cybersecurity Help (SB20261015141) 9.3 (CVSS v4) Scores attack requirements as none

The key element in React's vector is AT:P, "attack requirements present". The attack is network-based, needs no account and no user interaction, and is rated low complexity, but the application must contain the vulnerable response pattern. A critical score here does not mean every application running an affected package has a usable attack path. It does mean that where the pattern exists, the impact is full compromise of the server.


Exploitation status

As of November 10, React, Vercel, and CISA have reported no exploitation in the wild. However, after nearly four weeks with no public exploit, proof-of-concept code is now public.

Public proof-of-concept code

ThreatDefence has tracked three public repositories claiming working exploits, none of which it has independently verified:

Date What was published
October 17 A repository claiming exploit code for the Next.js advisory, GHSA-673q-mjm6-r5xr
November 8 A repository claiming a working exploit and Docker test lab for GHSA-xqc2-xf4c-x3h3
November 9 A repository claiming unauthenticated code execution against react-server-dom-webpack 19.2.8, and none against 19.2.9, built by comparing the two releases' source code

The November 9 approach matters: it shows the fix itself was enough to work backwards to an exploit, even though React and Vercel deliberately published few technical details to give users time to patch.

One of the public projects, a Python exploit with a deliberately vulnerable Docker lab, gives the clearest picture so far of what an attack looks like. Its author reports that against a test application on Next.js 16.4.0 and React 19.3.0, the exploit:

  1. Finds the ID of a Server Action (a server-side function the application exposes to the browser) from the target page or its JavaScript files.
  2. Sends a crafted request to a page that uses a cached lookup, triggering the serialisation desync.
  3. Causes that real Server Action to run with an argument the attacker chooses, and reads the result back from the rendered page.

Against the patched Next.js 16.4.1, the author reports the payload has no effect.

This adds useful detail to React's "extremely rare" wording. According to the author, a successful attack needs:

  • A use cache function returning multiple typed arrays alongside an attacker-controlled value
  • A Server Action the attacker can reach, and knowledge of the argument it expects
  • Knowledge of how the target's cached data is laid out; the exploit's defaults fit only its own lab, and other applications may require source code access or scanning

The author is also candid that real-world impact depends on what the Server Action does with the attacker's argument. In the lab, the action passes its argument to a system shell, so the demonstration runs shell commands. In a real application, the outcome could range from harmless to full server compromise, depending on what Server Actions exist. That makes Server Actions that touch the file system, run commands, query databases, or call internal services the highest-risk targets.

We have not tested any of this code, and we recommend that you do not run unvetted exploit code outside an isolated lab. During React2Shell, Trend Micro counted roughly 145 fake proof-of-concept exploits in circulation, most of which did not trigger the real vulnerability.

Points of confusion

  • This is not "React2Shell 2.0". React2Shell (CVE-2025-55182) was a CVSS 10.0 deserialisation flaw in the same three packages that worked against default setups and was exploited at scale, including by state-sponsored groups and cryptomining operations, within hours of disclosure. GHSA-xqc2-xf4c-x3h3 needs a specific response shape, attacker-controlled input, and a usable Server Action. Attacks on React2Shell are not evidence that this flaw is being exploited.
  • The late-October proof of concept is for something else. Upwind reports that a proof of concept circulating in late October belongs to a different flaw, a Node.js Brotli bug known as Node2Shell.

Attention on this advisory jumped sharply on November 8 and 9, after weeks of near silence, and exploit code followed within a day. The prerequisites mean mass exploitation of the kind seen with React2Shell is unlikely, but targeted attacks against applications whose code is public, such as open source projects and templates, are realistic. Assume scanning has begun.


What you should do

1. Upgrade, without deciding whether you "need to"

React and Vercel offer no workaround. Upgrade rather than trying to prove your code does not contain the vulnerable pattern.

  • Next.js 16: upgrade to 16.4.1 or later. Vercel shipped further security releases on November 3, so the current target is 16.4.5.
  • Next.js 15: 15.x is not listed as affected by GHSA-673q-mjm6-r5xr, but the 15.5 line has its own fixes for the other October 14 issues (see below). Move to 15.5.29, the November 3 security release. Next.js 15.0 to 15.4 and 14.x have received no fixes for those issues and should be moved to a supported line.
  • Other RSC frameworks and custom setups: upgrade react-server-dom-webpack, react-server-dom-turbopack, or react-server-dom-parcel to 19.0.9, 19.1.10, 19.2.9, or 19.3.1, matching your release line, and check your framework vendor for an updated release.

2. Check versions directly, not through your scanner

  • In Next.js projects, run npm ls next in every repository and container image to see the version actually resolved.
  • Outside Next.js, search your lockfile (package-lock.json, yarn.lock, or pnpm-lock.yaml), not just package.json, for the three react-server-dom-* packages.
  • Search by advisory ID (GHSA-xqc2-xf4c-x3h3 and GHSA-673q-mjm6-r5xr) in any tool that supports it. Do not treat a clean npm audit or CVE scan as proof.
  • To confirm the fixed code is actually present, including the copy bundled inside Next.js, check for a function the patch introduced. Researchers publishing on the flaw note that the patched server build contains getBackingBlob and the vulnerable build does not. A count of zero from grep -c getBackingBlob against the react-server-dom-webpack server build, either in node_modules/react-server-dom-webpack/cjs/ or in node_modules/next/dist/compiled/react-server-dom-webpack/cjs/, indicates vulnerable code. Treat this as a supporting check, not a replacement for confirming the version.

3. If you cannot upgrade today

There is no vendor-endorsed workaround, and none of the following replaces the patch. The author of one public exploit suggests two interim steps:

  • Remove or change use cache functions that return multiple typed arrays alongside data a user can influence.
  • Audit Server Action authorisation. The published attack works by running an existing Server Action with an attacker-chosen argument, so actions that check who is calling them and validate their input limit what an attacker can achieve. This is good practice regardless.

4. Redeploy, and clean up old deployments

Updating a lockfile does not change what is already running. Rebuild and redeploy every affected application. Pay particular attention to preview and branch deployments, which keep serving the old bundle until they are redeployed or deleted, and are often forgotten.

5. Patch the rest of the October 14 release while you are there

The same Next.js out-of-band release fixed two other serious issues:

  • CVE-2026-96889 / GHSA-2464-fhr4-w9xw (Critical): remote code execution in the Image Optimization API when processing SVG files, via the librsvg library used by sharp, on glibc-based Linux. Upgrading Next.js pulls in a fixed sharp; as an interim step, ensure sharp is 0.35.5 or later.
  • GHSA-p3m5-59mp-jv5r / GHSA-h3gv-c5rc-p453 (High): a denial-of-service flaw where crafted requests to App Router applications with at least one Server Action drive CPU usage high enough to block other requests.

6. Watch for signs of compromise

Neither React nor Vercel has published indicators of compromise. The public exploit code and ThreatDefence's hunting guidance suggest the following signals.

Signs of the attack itself:

  • Unusually long base64-encoded annotation query parameters on page requests
  • Responses containing a <pre> block with serialised Server Action output where none is expected
  • Bursts of POST requests that end in 5xx errors, and unexpected next-action or rsc-action-id headers at your proxy or load balancer; note that the author of one public exploit says it needs neither a multipart POST nor a Next-Action header, so the absence of these is not reassurance

Signs of what happens next:

  • A Node.js (or Bun) process spawning sh, bash, whoami, id, uname, curl, wget, nc, or similar
  • Files written by Node.js to /tmp, /var/tmp, /dev/shm, or Windows temp folders and executed shortly afterwards
  • Node.js connecting to the cloud metadata address 169.254.169.254, tunnelling services such as trycloudflare, ngrok, or anondns, or public IP addresses on ports other than 80 and 443
  • Commands or file reads targeting secrets: printenv, /proc/self/environ, .aws/credentials, Kubernetes service account tokens, or authorized_keys

Also review whether your Server Action IDs (visible as $ACTION_ID_… or in createServerReference calls) are exposed in HTML or client JavaScript. This is normal for Next.js, but it is how the published exploit finds its target, so it helps to know which actions are reachable and what they do.


A note on the pattern

Vulnerability management in most organisations runs on CVEs. Scanners match them, dashboards count them, and risk reports are built from them. GHSA-xqc2-xf4c-x3h3 shows how fragile that dependency is. A critical, unauthenticated remote code execution flaw in one of the most widely used web frameworks has spent nearly a month without a CVE, without a confirmed entry in GitHub's global advisory database, and with release notes that do not mention security. For a large share of affected organisations, nothing would have flagged it. Now there is public exploit code, and the flaw still cannot appear in the catalogue many organisations use to decide what to patch first.

This is not a one-off. Open source projects increasingly publish through GitHub Security Advisories first, and the gap between that and a CVE can be days, weeks, or indefinite. Teams that also watch the advisories of the frameworks they depend on, and that can answer "which applications are running which version of this package?" without waiting for a scanner, are the ones that patched this on October 14.


Summary

Advisory GHSA-xqc2-xf4c-x3h3 (React); GHSA-673q-mjm6-r5xr (Next.js)
CVE None assigned
Component React Server Components Flight response writer (react-server-dom-webpack, -turbopack, -parcel)
Type Unauthenticated remote code execution via stream framing desync with typed arrays
Severity 9.5 Critical (CVSS v4, React and Next.js); 10.0 (CVSS 3.1, GitLab for Next.js)
Trigger Response carrying multiple typed arrays and an attacker-controlled value; in Next.js, a use cache function returning multiple typed arrays
Affected RSC packages 19.0.0 to 19.0.8, 19.1.0 to 19.1.9, 19.2.0 to 19.2.8, 19.3.0; Next.js 16.0.0 to 16.4.0 with Cache Components
Fixed RSC packages 19.0.9, 19.1.10, 19.2.9, 19.3.1; Next.js 16.4.1 (current: 16.4.5; 15.5.29 for the 15.5 line)
Not affected Client-only React apps; apps without an RSC-capable server, framework, or bundler
Workaround None from the vendors; interim steps are to remove risky use cache functions and harden Server Action authorisation
Proof of concept Public, unverified: Next.js advisory (October 17); React advisory (November 8 and 9)
Exploitation None reported by React, Vercel, or CISA as of November 10
Disclosed October 14, 2026; credited to evolutionstorm
Why it is missed No CVE; not eligible for CISA KEV; GitHub advisory database and Dependabot coverage unconfirmed; Next.js bundles its own RSC copy
Detection Long base64 annotation parameters; unexpected Server Action output; Node.js spawning shells, reaching metadata or tunnel services, or reading secrets

GHSA-xqc2-xf4c-x3h3 is narrow in its trigger but severe in its impact, and with exploit code now public, the time to quietly get around to it has passed. Check your Next.js and RSC package versions directly, upgrade and redeploy, and do not wait for a scanner to tell you this one matters.

If you need help finding every application running an affected React or Next.js version, confirming that what is deployed matches what was patched, or building advisory monitoring that does not depend on CVEs alone, get in touch. For flaws like this one, the hardest part is knowing you need to look.

← all insights