On the morning of 3 December 2025, the React team published a short blog post with a very long tail. A bug in React Server Components, the technology behind a huge number of modern websites built with Next.js, let anyone on the internet run their own code on a vulnerable server. No password. No user account. Just one carefully shaped web request.
Security people nicknamed it React2Shell, a nod to Log4Shell from 2021, and the comparison wasn't just for headlines. Within hours, attackers were scanning the internet for targets. Within two days, the US government had added it to its list of vulnerabilities being actively exploited in the wild.
We build a lot of sites on React and Next.js, including this one, so we followed it closely. Nearly a year on, it's still the clearest recent example of why "we'll patch it next sprint" isn't a plan. Here's what happened, in plain language, and what we think every business with a website should take from it.
10.0
CVSS severity score, the maximum possible
React team advisory
Hours
From public disclosure to the first attack attempts
Amazon threat intelligence via The Hacker News
2 days
Until CISA listed it as actively exploited
CISA KEV, 5 Dec 2025
0
Workarounds. Upgrading was the only fix
Next.js security update
What React2Shell actually was
React Server Components let part of a website run on the server instead of in the visitor's browser. To make that work, the browser and server pass specially encoded messages back and forth.
React2Shell was a flaw in how the server decoded those messages. The React team's advisory describes it simply: an unauthenticated attacker could craft an HTTP request to a Server Function endpoint that, when decoded, executed code on the server. In security terms that's remote code execution, the worst category there is. Once an attacker can run code on your server, they can read your data, steal stored credentials, install malware, or use your machine to attack others.
Two details made it particularly nasty:
- You didn't have to be using the risky feature directly. The advisory warned that apps without their own Server Function endpoints could still be vulnerable if they supported React Server Components at all.
- It sat in the default setup. A brand new Next.js app on an affected version, built with the App Router, was exposed out of the box. Nobody had to misconfigure anything.
How a React2Shell attack unfolded
- 01
Scan
Bots sweep the internet for sites running vulnerable React or Next.js
- 02
One request
A crafted HTTP request hits the server. No login needed
- 03
Code runs
The server decodes the payload and executes the attacker's code
- 04
Foothold
Miners, backdoors and credential theft follow
Who was affected
The vulnerable code lived in three React packages (react-server-dom-webpack, react-server-dom-parcel and react-server-dom-turbopack) in versions 19.0, 19.1.0, 19.1.1 and 19.2.0. Because frameworks bundle those packages, the blast radius was much wider: Next.js, React Router, Waku, Parcel's and Vite's RSC plugins, and RedwoodSDK were all named.
For Next.js specifically, the risk was in apps using the App Router on the 15.x and 16.x lines, plus some 14.x canary builds. Sites built with the older Pages Router weren't affected by the remote code execution bug, and neither were sites that only use React in the browser.
| If your site uses… | Exposed to React2Shell? |
|---|---|
| Next.js 15.x or 16.x with the App Router (before patching) | Yes |
| Next.js 14.3.0-canary.77 or later canaries | Yes |
| Next.js 13.x or stable 14.x | No, but patch for the follow-up bugs |
| Pages Router only | No |
| React in the browser only, no server rendering | No |
How fast it went from advisory to attacks
This is the part that should change how you think about updates. The fix was ready before the public announcement, which is how responsible disclosure is supposed to work. Attackers still moved faster than most businesses.
- 29 Nov 2025
Reported privately
Researcher Lachlan Davidson reports the bug through Meta's bug bounty programme.
- 1 Dec 2025
Fix built
The React team creates a patch and quietly works with hosting providers on temporary protections.
- 3 Dec 2025
Public disclosure
Patched packages ship to npm and CVE-2025-55182 is published with a 10.0 severity score.
- 3–4 Dec 2025
Attacks begin
Amazon reports exploitation attempts within hours, linked to China-nexus groups. Public proof-of-concept code appears the next day.
- 5 Dec 2025
Officially 'actively exploited'
CISA adds the flaw to its Known Exploited Vulnerabilities catalogue and orders US federal agencies to patch.
- 11 Dec 2025
Follow-up bugs
Researchers examining the patch find two more issues: a denial-of-service bug and a source code leak. Neither allows code execution, but both need patching.
The number of exposed servers fell quickly as teams patched, but "quickly" still left tens of thousands of servers open for days. The Shadowserver Foundation, which scans the internet for vulnerable systems, published counts in the first week:
Vulnerable IP addresses seen by Shadowserver

What attackers did once they got in
Reports from security firms including Palo Alto Networks' Unit 42, Wiz, VulnCheck and Amazon, collected in The Hacker News' coverage, paint a familiar picture. Once inside, attackers:
- installed cryptocurrency miners that quietly burn your server bill,
- recruited servers into botnets such as Mirai and RondoDox,
- tried to steal cloud credentials, including AWS configuration files, which can turn one hacked website into a breach of your whole cloud account, and
- planted backdoors for persistent access, from web shells to tools like Sliver and Cobalt Strike.
None of that requires a sophisticated attacker. Most of it was automated, opportunistic and aimed at whoever hadn't patched yet. Small businesses often assume they're too minor to bother with, and with this kind of attack that assumption simply doesn't hold.
You don't have to be an interesting target to get hit by something like React2Shell. You just have to be a slow one.
The lessons we're still applying
React2Shell was patched long ago, but the habits it exposed are the same ones that decide how the next critical bug goes for you.
1. Know what you're running
When the advisory dropped, the first question was "are we affected?" Teams that could answer in minutes were patched the same day. Teams that had to dig through old projects, forgotten microsites and an agency's handover notes from two years ago lost days. Keep a simple list of every site and app you run, the framework and version behind each one, and who looks after it.
2. Treat critical patches as same-day work
A 10.0 vulnerability with public exploit code isn't a ticket for next sprint. Agree in advance, with your team or your agency, what counts as an emergency and who's allowed to deploy outside the normal release window. Writing that down before you need it is most of the work.
3. Don't lean on your host's safety net
Hosting providers and firewalls rolled out temporary blocking rules, and that genuinely helped. But the React team was blunt that those protections were stopgaps, and the Next.js team said there was no workaround short of upgrading. A firewall rule buys you hours, not safety.
4. Patch, then check you weren't already hit
CISA asked agencies not just to patch but to look for signs of compromise afterwards. If a server was exposed during the window when attacks were running, updating the code doesn't remove a miner or backdoor that's already been installed. Check for unfamiliar processes, unexpected outbound traffic and new user accounts, and rotate any credentials stored on that server.
5. Expect a sequel
Big fixes attract attention. Within eight days, researchers studying the React2Shell patch had found two more flaws, and the first fix for one of them turned out to be incomplete and needed a second release. When a critical bug lands, plan to update more than once over the following weeks.
A 15-minute check for any React or Next.js site you own
- Find the exact Next.js and React versions in each project's package-lock.json, not just package.json.
- Compare them with the patched versions in the Next.js security update for your release line.
- If anything is behind, upgrade. On Next.js, the official npx fix-react2shell-next tool checks and bumps versions for you.
- Redeploy, then confirm the live site is actually running the new build.
- If a site was exposed in December 2025, check its server for unknown processes and rotate its stored credentials.
- Write down who gets called next time a critical advisory drops, and how fast you expect them to act.
The short version
React2Shell was a maximum-severity bug in one of the most widely used web technologies, and it went from announcement to active exploitation in hours. The businesses that came through it untouched weren't the ones with the fanciest security tools. They were the ones that knew what they were running, had someone responsible for it, and patched the same day.
If you're not sure whether your website is up to date, or who would handle the next emergency patch, that's worth sorting out on a quiet day rather than a loud one.
Force Media builds and maintains fast, secure websites and web apps on React and Next.js. If you'd like a second pair of eyes on your stack, or someone to own patching so you don't have to, get in touch. For a broader look at keeping your tools working for you, see our guide to AI agents for business.



