CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2025-11953

React Native's Open Door Policy: The Anatomy of CVE-2025-11953

Alon Barad
Alon Barad
Software Engineer

Feb 4, 2026·6 min read·112 visits

Executive Summary (TL;DR)

A critical RCE in @react-native-community/cli (Metro Server) allows attackers on the same network to execute arbitrary commands on a developer's machine via the `/open-url` endpoint. The server fails to sanitize input before passing it to the OS shell.

In the world of modern development, 'Developer Experience' (DX) is king. Tools are designed to be frictionless, magical, and zero-config. But sometimes, that magic involves binding a server to 0.0.0.0 and letting unauthenticated network traffic execute shell commands on your workstation. CVE-2025-11953 is a critical Remote Code Execution (RCE) vulnerability in the React Native CLI's Metro server that turns a developer's convenience into a hacker's playground.

The Hook: Convenience at a Cost

Let's set the scene. You're a React Native developer. You're sitting in a coffee shop, sipping an overpriced oat latte, iterating on your new app. Your phone is connected to your laptop, and the Metro Bundler is running, serving JavaScript bundles to your device. To make this seamless, the Metro server (part of @react-native-community/cli) typically binds to 0.0.0.0 (all interfaces) so your phone can reach it over the local network. It listens on port 8081.

Here's the problem: Metro isn't just serving static files. It includes 'middleware'—helper endpoints designed to improve your workflow. Specifically, it has endpoints like /open-url and /open-stack-frame. The idea is brilliant: if your app crashes on your phone, you tap a button, the phone sends a request to your laptop, and your laptop opens the offending file in VS Code or opens a documentation URL in Chrome. It's magical.

But for a security researcher, 'magic' usually translates to 'unvalidated input'. That helper endpoint is effectively a remote control for your operating system. And because the server binds to 0.0.0.0, that remote control isn't just in your hand—it's available to anyone on the same Wi-Fi network. That guy in the corner with the hoodie? He's not debugging his startup; he's scanning for port 8081.

The Flaw: Trusting User Input

The vulnerability (CWE-78) lies in how the Metro server handles requests to these helper endpoints. The logic was deceptively simple: receive a JSON payload containing a URL, and tell the operating system to 'open' that URL. On the surface, this looks like open('http://google.com').

However, under the hood, the library used to perform this action interacts with the underlying OS shell. On Windows specifically, this often translates to spawning a process via cmd.exe. The developers made a classic blunder: they took the input directly from the HTTP request body—data completely controlled by the user—and passed it into a command execution sink without strict sanitization.

It's the digital equivalent of a bank teller blindly accepting a note that says 'Give me all the money' because it was written on official-looking stationary. The code didn't check if the 'URL' was actually a URL. It just checked if it was a string, and then handed it to the shell. This is where the syntax of cmd.exe becomes a weapon. By appending command separators like & or |, an attacker can turn a request to open a website into a request to open a website and run ransomware.

The Code: The Smoking Gun

Let's look at the code. This isn't just a theoretical bug; it's a stark example of why input validation is non-negotiable. Before the patch, the openURLMiddleware looked something like this (simplified for dramatic effect):

// VULNERABLE CODE
const openURLMiddleware = async (req, res, next) => {
  const { url } = JSON.parse(req.body);
  // "Sure, I'll open that for you!"
  await open(url);
  res.end('OK');
};

The open() function eventually calls child_process.spawn or exec. If url contains shell metacharacters, they get executed. Now, let's look at the fix in commit 15089907d1f1301b22c72d7f68846a2ef20df547. The maintainers realized they couldn't just trust the string. They needed to validate that it was, in fact, a valid URL protocol.

// FIXED CODE (Commit 15089907d1f1)
async function openURLMiddleware(req, res, next) {
  const { url } = req.body;
  try {
    // 1. Force parsing. If it's not a URL, this throws.
    const parsedUrl = new URL(url);
 
    // 2. Allowlist protocols. No 'file:', no 'javascript:', and definitely no shell hacks.
    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
       res.writeHead(400); return res.end('Invalid protocol');
    }
  } catch (e) {
    res.writeHead(400); return res.end('Invalid URL');
  }
  await open(url);
  res.end();
}

By enforcing new URL(url), they rely on the WHATWG URL standard to parse the string. If you try to inject http://site.com & calc.exe, the URL parser will either throw an error (invalid character) or URL-encode the malicious parts, rendering them harmless to the shell. It's a robust fix because it validates the structure of the data, not just looking for 'bad characters'.

The Exploit: Popping Calc (and Shells)

So, how do we break it? Imagine you are on a shared network. You run a quick nmap scan and see port 8081 open on a nearby IP. It identifies as the Metro Bundler. It's showtime.

The attack vector is a simple HTTP POST request. You don't need authentication. You don't need cookies. You just need to send JSON.

The Payload:

curl -X POST http://192.168.1.50:8081/open-url \
     -H "Content-Type: application/json" \
     -d '{"url": "http://google.com & calc.exe"}'

When the server processes this on a Windows machine, the constructed command effectively becomes:

cmd /c start http://google.com & calc.exe

The browser opens Google, and moments later, the Calculator app pops up. While calc.exe is the harmless 'Proof of Concept' standard, replace that with a PowerShell one-liner to download a Cobalt Strike beacon, and you own the developer's laptop. The /open-stack-frame endpoint is equally vulnerable, accepting file and lineNumber parameters that are just as susceptible to injection.

The Impact: Why This Hurts

Why is this CVSS 9.8? Because it hits developers where they live. A developer's workstation is the crown jewel of corporate targets. It has SSH keys to production servers. It has AWS credentials in ~/.aws/credentials. It has the source code for the company's proprietary IP. It has VPN access to the internal network.

By compromising one developer via a drive-by Wi-Fi attack or a CSRF attack (if the developer visits a malicious site that fires a request to localhost:8081), an attacker gains a foothold inside the perimeter. From there, lateral movement is trivial. The fact that this requires zero user interaction and zero privileges makes it terrifying. The developer doesn't even see a prompt; the command just executes in the background.

The Fix: Shutting It Down

The immediate fix is to upgrade @react-native-community/cli to version 20.0.0 or later. The React Native team was responsive and the patch is solid. However, relying solely on patching is reactive. We need to talk about defense in depth.

1. Bind to Localhost: There is rarely a good reason for Metro to listen on 0.0.0.0 in a coffee shop. Configure your metro.config.js to bind to 127.0.0.1 unless you explicitly need to debug on a physical device that can't connect via USB.

// metro.config.js
module.exports = {
  server: {
    host: '127.0.0.1'
  }
};

2. Firewall Rules: Developers often disable local firewalls 'to make things work'. Don't. Ensure your OS firewall blocks incoming connections to non-standard ports (like 8081) on public networks. Treat your local dev server like a production server: if it doesn't need to be public, don't make it public.

Official Patches

GitHubCommit fixing the vulnerability by implementing URL validation.

Fix Analysis (1)

Technical Appendix

CVSS Score
9.8/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
EPSS Probability
0.40%
Top 39% most exploited
5,000
via Shodan

Affected Systems

React Native Development EnvironmentsMetro BundlerWindows Workstations (Primary Target)macOS/Linux Workstations (Secondary Target)

Affected Versions Detail

Product
Affected Versions
Fixed Version
@react-native-community/cli
React Native Community
>= 4.8.0 < 20.0.020.0.0
AttributeDetail
CWE IDCWE-78 (OS Command Injection)
CVSS v3.19.8 (Critical)
Attack VectorNetwork (AV:N)
EPSS Score0.405% (Rising)
Vulnerable ComponentMetro Server Middleware (openURL)
Exploit StatusProof of Concept Available

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1059.003Command and Scripting Interpreter: Windows Command Shell
Execution
T1203Exploitation for Client Execution
Execution
CWE-78
OS Command Injection

The software constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command.

Known Exploits & Detection

GitHubPython script demonstrating remote command execution on Windows targets.

Vulnerability Timeline

Patch Committed to GitHub
2025-08-04
Public Disclosure & CVE Assigned
2025-11-03
PoC Released
2025-11-04
Multiple PoCs circulate
2026-01-01

References & Sources

  • [1]JFrog Security Analysis
  • [2]ZeroPath Technical Report

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•14 minutes ago•CVE-2026-114146
9.0

CVE-2026-114146: Elevation of Privilege in ASP.NET Core SignalR Connection Dispatcher

An incorrect authorization vulnerability (CWE-863) exists in the ASP.NET Core SignalR HTTP Connection Dispatcher (`Microsoft.AspNetCore.Http.Connections`). The connection negotiation process failed to bind the authenticated caller identity to the generated connection state, and subsequent transport or message dispatch handlers failed to verify caller consistency. Consequently, an authenticated low-privilege attacker who obtains a valid connection identifier or token can inject messages into or hijack another user's SignalR session, achieving an elevation of privilege across security boundaries.

Alon Barad
Alon Barad
0 views•11 min read
•about 1 hour ago•CVE-2026-109478
7.5

CVE-2026-109478: Algorithmic Complexity Denial of Service in ASP.NET Core Header Parsing

CVE-2026-109478 is a network-accessible Denial of Service (DoS) vulnerability in ASP.NET Core caused by inefficient algorithmic complexity (CWE-407) when parsing comma-separated HTTP request headers. Prior to the patch, the internal helper method ParsingHelpers.GetHeaderSplit repeatedly called StringValues.Concat inside a loop iterating over each comma-separated token. Because StringValues allocates a new array of size k + 1 and copies all existing elements upon each concatenation, processing N tokens incurs O(N^2) time and space complexity. An unauthenticated remote attacker can send HTTP requests with headers containing thousands of short, comma-separated values to exhaust CPU cycles and induce severe Garbage Collection (GC) pauses, rendering the web application unresponsive.

Alon Barad
Alon Barad
5 views•11 min read
•about 2 hours ago•CVE-2026-114147
7.5

CVE-2026-114147: Denial of Service via Memory Leak in ASP.NET Core SignalR Redis Backplane

CVE-2026-114147 is a high-severity Denial of Service (DoS) vulnerability affecting ASP.NET Core and specifically the Microsoft.AspNetCore.SignalR.StackExchangeRedis scale-out provider across .NET 8.0, 9.0, 10.0, and 11.0 preview releases. The vulnerability originates from a string comparison mismatch between internal per-connection group collections and the centralized Redis channel subscription registry, compounded by a race condition during connection teardown. Remote unauthenticated attackers can exploit this flaw to leave orphaned connection contexts and active Redis pub/sub listeners pinned in memory, leading to unbounded memory exhaustion and application process termination.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•CVE-2026-114156
6.5

CVE-2026-114156: Path Equivalence Security Feature Bypass in Microsoft ASP.NET Core

CVE-2026-114156 is an improper resolution of path equivalence vulnerability (CWE-41) in Microsoft ASP.NET Core affecting .NET 11.0 preview releases and Microsoft Visual Studio 2026. The vulnerability stems from a discrepancy between how path prefix validation helpers (such as PathString.StartsWithSegments) and downstream routing mechanisms handle alternate path separators and percent-encoded characters. An unauthenticated remote attacker can exploit this mismatch over the network to bypass path-based authorization middleware and access restricted endpoints.

Amit Schendel
Amit Schendel
5 views•8 min read
•about 4 hours ago•CVE-2026-114157
7.5

CVE-2026-114157: Local Privilege Escalation via Race Condition in ASP.NET Core Kestrel Named Pipes Transport

CVE-2026-114157 is a high-severity local privilege escalation and security feature bypass vulnerability affecting ASP.NET Core on Microsoft Windows. The flaw resides in the Kestrel web server's Named Pipes transport layer (Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes) and stems from a race condition (CWE-362) during broken pipe error recovery. When an active connection throws an IOException during handshake acceptance, the connection listener previously disposed of the broken NamedPipeServerStream instance before acquiring a replacement stream from its internal pool. This sequence created a momentary window where zero server instances of the named pipe existed in the Windows Named Pipe File System (NPFS). A local, low-privileged attacker can exploit this timing window to create a named pipe with the identical name and a permissive Discretionary Access Control List (DACL), hijacking subsequent inter-process communications and escalating privileges across security boundaries.

Amit Schendel
Amit Schendel
6 views•11 min read
•about 5 hours ago•CVE-2026-124194
6.5

CVE-2026-124194: Forced Authentication and NetNTLMv2 Credential Leakage in Microsoft Office Outlook

CVE-2026-124194 is a forced authentication and spoofing vulnerability in Microsoft Office Outlook caused by a missing user interface warning before dereferencing remote network paths (CWE-356). By embedding an attacker-controlled Universal Naming Convention (UNC) path within MAPI message properties such as PidLidReminderFileParameter, an unauthenticated remote attacker can force a victim's system to initiate an outbound SMB or WebDAV connection upon opening or previewing a crafted message. This automatic authentication handshake leaks the user's NetNTLMv2 hash, enabling offline password cracking or real-time NTLM relay attacks. The vulnerability was exploited in the wild as a zero-day prior to its remediation in Microsoft's November 2026 Patch Tuesday updates and is listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.

Alon Barad
Alon Barad
17 views•10 min read