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, orreact-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 auditreads, 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
nextpackage. A dependency check forreact-server-dom-webpackin a Next.js app can come back empty while the vulnerable code is present, and upgradingreactandreact-domdoes not replace that bundled copy. Only a newnextrelease 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:
- 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.
- Sends a crafted request to a page that uses a cached lookup, triggering the serialisation desync.
- 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 cachefunction 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, orreact-server-dom-parcelto 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 nextin every repository and container image to see the version actually resolved. - Outside Next.js, search your lockfile (
package-lock.json,yarn.lock, orpnpm-lock.yaml), not justpackage.json, for the threereact-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 auditor 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
getBackingBloband the vulnerable build does not. A count of zero fromgrep -c getBackingBlobagainst thereact-server-dom-webpackserver build, either innode_modules/react-server-dom-webpack/cjs/or innode_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 cachefunctions 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
librsvglibrary used bysharp, on glibc-based Linux. Upgrading Next.js pulls in a fixedsharp; as an interim step, ensuresharpis 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
annotationquery 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-actionorrsc-action-idheaders at your proxy or load balancer; note that the author of one public exploit says it needs neither a multipart POST nor aNext-Actionheader, 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 astrycloudflare,ngrok, oranondns, 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, orauthorized_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.