Skip to content
Christopher Shaun Godwin
Blog

Server Components

1 post with the tag “Server Components”

The React Flaw That Triggered Cloudflare's Massive Outage: Unpacking the RCE Nightmare

Christopher Shaun Godwin
Author

A critical vulnerability in React’s latest serialization mechanisms didn’t just expose servers to remote code execution (RCE)—it inadvertently brought down Cloudflare itself, spiking error rates to 22-25 million 500s per second and disrupting a significant slice of the internet.

The flaw, rooted in React 19’s React Server Components (RSC) and its “flight protocol,” revolves around a subtle deserialization issue. Modern React apps, especially those powered by frameworks like Next.js, stream JSON payloads from server to client containing unresolved promises marked for later resolution. These payloads use “model strings”—starting with a dollar sign ($)—to reference chunks of data by index.

The Payload That Unlocks Arbitrary Code

Section titled “The Payload That Unlocks Arbitrary Code”

The minimal reproduction, credited to Vercel’s own researcher (dubbed “top G”), crafts a malicious payload with two chunks (0 and 1):

  • Chunk 0 holds a promise-like structure.
  • Chunk 1 references it via a model string ($@0), with a value that’s another model string of type “B”: $B{...}.

React’s parseModelString processes these. The “B” type dives into React’s internal state, where attacker-controlled data slips into response.formData and response.get. Here’s the killer: response.get is rigged as a model string pointing to Promise.prototype.then.constructor.

// Simplified exploit chain
const thenConstructor = Promise.prototype.then.constructor;
// thenConstructor === Function constructor
const maliciousFn = new thenConstructor(`console.log('RCE!'); /* payload */`);
maliciousFn(); // Executes arbitrary code

When React decodes the “B” type using formData.get(prefix + id), it invokes the Function constructor with a comment-terminated string payload. No authentication needed—just craft the prefix, and server-side code like curling environment variables runs freely.

This isn’t theoretical. The researcher, Lackland Davidson, invested over 100 hours reverse-engineering it, proving sites remain vulnerable if unpatched.

Cloudflare’s Well-Intentioned Fix Backfires

Section titled “Cloudflare’s Well-Intentioned Fix Backfires”

React teams scrambled, but Cloudflare stepped up to shield the web. Suspecting oversized payloads fueled attacks, they bumped their Workers’ HTTP buffer from 128KB to 1MB—aligning with Next.js recommendations.

Rollout seemed smooth until their internal FL1 testing tool (Lua-based firewall layer) choked on the larger buffers. Engineers, prioritizing the RCE crisis, disabled the tool.

Disaster struck in FL1’s request handling. Certain requests bear an “execute” tag, delegating to secondary rule sets:

-- Simplified Lua pseudocode from FL1
if rule_set.action == "execute" then
  local extra_results = get_action_results(rule_set)  -- Returns nil (disabled tool)
  -- Dereference nil -> crash
end

Nil results cascaded: no rule set evaluation, unhandled errors, and cascading 500s across frontline servers. Ironically, FL2—the Rust-rewritten upgrade—stayed rock-solid, thanks to Rust’s compile-time safety nets preventing null dereferences.

Lessons from History and Modern Hype

Section titled “Lessons from History and Modern Hype”

This echoes a 1994 Sun Microsystems paper warning against treating client and server as a uniform object space without location-aware serialization. Java learned it the hard way; now JavaScript’s blurring boundaries revive the peril.

React’s ubiquity—from SPAs to full-stack—amplifies the blast radius. Upgrade immediately, validate payloads rigorously, and remember: serialization is a minefield. One infinite loop or prototype chain gadget can topple empires.

Rust fans rejoice—FL2 proved memory safety’s worth in production. For the rest, patch fast; unpatched sites are still ticking bombs.

The Dangers of “Smart Pipes”

Section titled “The Dangers of “Smart Pipes””

Beyond the specific bug, this incident serves as a stark architectural warning about “Edge Creep.” CDNs were originally designed as “dumb pipes” to cache static assets. Today, we are asking them to parse complex, evolving application-layer payloads (like React serialization) at the edge. When infrastructure tries to be too smart—inspecting and manipulating deep application logic—it inherits the fragility of that logic. Cloudflare’s outage wasn’t just a React bug; it was a failure of the “Smart Edge” promise, proving that sometimes, dumb and robust beats smart and fragile.