MCP Risk Register
The MCP Risk Register lists 42 risks for MCP servers in six dimensions: supply chain, authorization, transport and network, tool descriptions and schemas, execution and filesystem, and data exposure and logging. Each row has impact, controls, a written severity rule (19 high, 21 medium, 2 low) and primary sources read on 16 Nov 2026.
Facts read on .
All 42 items
| ID | Item | Category | Severity |
|---|---|---|---|
| R-01 | Look-alike package name (typosquatting) | Supply chain | high |
| R-02 | Repackaged server with altered endpoints | Supply chain | high |
| R-03 | Unreviewed code run through a package launcher | Supply chain | high |
| R-04 | Vulnerable or compromised dependency inside a server | Supply chain | medium |
| R-05 | Tool definitions change after approval (rug pull) | Supply chain | medium |
| R-06 | Registry listing mistaken for a security review | Supply chain | medium |
| R-07 | Unknown servers configured on developer machines | Supply chain | high |
| R-08 | Token passthrough and missing audience validation | Authorization | high |
| R-09 | HTTP endpoint reachable without authentication | Authorization | high |
| R-10 | Confused deputy at an MCP proxy server | Authorization | medium |
| R-11 | Client credentials sent to a server-chosen authorization server | Authorization | high |
| R-12 | Over-broad token scopes | Authorization | medium |
| R-13 | Authorization policy skipped on direct calls | Authorization | medium |
| R-14 | Authorization server mix-up and unverified issuer | Authorization | medium |
| R-15 | State handle or message delivered to the wrong client | Authorization | medium |
| R-16 | DNS rebinding against a local HTTP server | Transport and network | high |
| R-17 | Local server listening on all interfaces | Transport and network | medium |
| R-18 | Server-side request forgery through discovery and fetch tools | Transport and network | high |
| R-19 | Credentials carried across cross-origin redirects | Transport and network | medium |
| R-20 | Remote server without TLS or with unverified identity | Transport and network | medium |
| R-21 | Unbounded requests and sessions exhaust a server | Transport and network | low |
| R-22 | Unrestricted outbound access from server processes | Transport and network | medium |
| R-23 | Poisoned tool description | Tool descriptions and schemas | high |
| R-24 | Tool shadowing across servers | Tool descriptions and schemas | medium |
| R-25 | Hostile content in schemas and return values | Tool descriptions and schemas | medium |
| R-26 | Annotations trusted as enforcement | Tool descriptions and schemas | medium |
| R-27 | Prompt injection through tool results | Tool descriptions and schemas | high |
| R-28 | Server-supplied schemas that exhaust or confuse clients | Tool descriptions and schemas | low |
| R-29 | Local server runs with the user's full privileges | Execution and filesystem | high |
| R-30 | Malicious startup command in configuration | Execution and filesystem | high |
| R-31 | Command injection through arguments or URL opening | Execution and filesystem | high |
| R-32 | Path traversal and arbitrary file read in file tools | Execution and filesystem | high |
| R-33 | Project configuration from a cloned repository | Execution and filesystem | high |
| R-34 | Tool calls auto-approved without full arguments | Execution and filesystem | high |
| R-35 | Developer tools that spawn processes on a port | Execution and filesystem | medium |
| R-36 | Secrets inherited through the environment | Data exposure and logging | high |
| R-37 | Tokens stored in plaintext | Data exposure and logging | medium |
| R-38 | Data exfiltration through legitimate tool calls | Data exposure and logging | high |
| R-39 | Sensitive data requested through form elicitation | Data exposure and logging | medium |
| R-40 | No record of tool calls | Data exposure and logging | medium |
| R-41 | Secrets and personal data written into logs | Data exposure and logging | medium |
| R-42 | Protected data returned through resources and templates | Data exposure and logging | medium |
What the register covers
The register is a working list for engineers who must decide which MCP servers developers may install and how to constrain them. It follows the MCP specification's own security pages and the OWASP MCP Security Cheat Sheet, and adds advisories and release notes dated from August to November 2026.
Rows describe the risk, the impact and the controls. They omit exploit code, payloads and bypass steps.
Sources: MCP Security Best Practices, 2026-07-28 revision; OWASP MCP Security Cheat Sheet; Local Server Security, modelcontextprotocol.io.
How the rows are organized
There are 42 rows with identifiers R-01 to R-42. Each belongs to one of six dimensions and has a severity, controls an engineer can apply and at least one primary source. The companion MCP Security Checklist maps its steps to these identifiers.
- Supply chain: 7 rows
- Authorization: 8 rows
- Transport and network: 7 rows
- Tool descriptions and schemas: 6 rows
- Execution and filesystem: 7 rows
- Data exposure and logging: 7 rows
Sources: OWASP MCP Top 10; MCP Authorization, 2026-07-28 revision.
What changed in the protocol in 2026
The 2026-07-28 revision removes protocol-level sessions and deprecates Sampling, Roots, Logging and Dynamic Client Registration, with earliest removal in the first revision released on or after 2027-07-28. Rows that mention sessions or registration note the revision they apply to.
SDK advisories published in October 2026 show where the specification's rules, such as token audience checks, needed code changes and, in some cases, a setting that upgrading alone does not enable.
Sources: MCP Security Best Practices, 2026-07-28 revision; GHSA-rvq5-wwqv-78pq: MCP TypeScript SDK bearer authentication audience; GHSA-w4fh-qvv9-3v23: MCP Python SDK bearer-token audience.
Item detail
R-01: Look-alike package name (typosquatting)
A package is published under a name one keystroke away from a trusted MCP server, in the hope that a developer or a script installs it by mistake.
Impact: The wrong package runs with the same permissions as the right one, including access to the user's files and environment variables.
Controls:
- Compare the exact package name, publisher and repository against the vendor's documentation before the first install.
- Keep an approved server list and block installs of anything not on it (VS Code and Copilot enterprise-managed settings use allowedMcpServers and deniedMcpServers; Claude Code uses managed-mcp.json).
- Pin the version once reviewed so a later publish under the same name is not picked up.
Severity: high
Sources: OWASP MCP Security Cheat Sheet (read ); Local Server Security, modelcontextprotocol.io (read ).
R-02: Repackaged server with altered endpoints
A package copies a legitimate server's open-source code but replaces authentication or API addresses, and the README does not mention the change. Knostic described one such npm package on 26 Oct 2026 and assessed it as suspected malicious credential redirection.
Impact: Application credentials the user supplies as environment variables go to a destination the user did not choose.
Controls:
- Diff the package contents against the upstream repository for endpoint and authentication changes before approval.
- Restrict outbound network access from MCP server processes to the hosts the server needs.
- Rotate any credential that was supplied to a server later found to be altered.
Severity: high
Sources: Repackaged Amazon SP-API MCP Sends App Secrets to an Undisclosed IP, Knostic (read ); Local Server Security, modelcontextprotocol.io (read ).
R-03: Unreviewed code run through a package launcher
Local MCP servers are often started by a launcher command such as npx, which fetches whatever the package name resolves to at that moment and runs it.
Impact: A new publish, a hijacked account or a changed dependency executes on the next start without a review step.
Controls:
- Install a pinned version and run it from a reviewed lockfile or image rather than resolving the latest at launch.
- Show the full launch command, unabridged, for approval before a server is added.
- Record the package name, version and hash of every approved server in the catalog.
Severity: high
Sources: MCP Security Best Practices, 2026-07-28 revision (read ); Local Server Security, modelcontextprotocol.io (read ).
R-04: Vulnerable or compromised dependency inside a server
An MCP server pulls in third-party packages, and a known flaw or a compromised release in any of them runs with the server's permissions.
Impact: A flaw in a dependency becomes code execution or data access on the machine that runs the server.
Controls:
- Scan server dependencies for known vulnerabilities before approval and on a schedule afterward.
- Verify package integrity with checksums or code signing where the publisher provides them.
- Subscribe to GitHub advisories for the servers and SDKs in the catalog and track fixed versions.
Severity: medium
Sources: OWASP MCP Security Cheat Sheet (read ); Evo ADS MCP Governance Goes GA, Snyk (read ).
R-05: Tool definitions change after approval (rug pull)
A server changes its tool names, descriptions or schemas after a user or reviewer approved it, turning a reviewed tool into a different one.
Impact: An approval given on day one no longer describes what the tool does on day thirty.
Controls:
- Hash the complete tool definition, including inputSchema, outputSchema and annotations, and require re-review when the hash changes.
- Re-prompt for consent when definitions change, and alert on listChanged notifications from servers not expected to change.
- Pin the server version so definitions only change on a reviewed upgrade.
Severity: medium
Sources: OWASP MCP Security Cheat Sheet (read ); MCP Tools, 2026-07-28 revision (read ).
R-06: Registry listing mistaken for a security review
The official MCP Registry stores metadata that points at packages on npm, PyPI and Docker Hub, and is described as a preview. A listing shows that a name was published, not that the code was reviewed.
Impact: Teams that build an approved list from registry data may admit a server that nobody read, or map two listings to one entry. The registry's v1.8.8 notes say different server names may share a remote URL.
Controls:
- Treat registry data as discovery input only and review the package behind each entry.
- Key catalog entries by server name and version, not by URL.
- Record the reviewer, date and version for each approved entry.
Severity: medium
Sources: About the MCP Registry (read ); MCP Registry v1.8.8 release notes (read ).
R-07: Unknown servers configured on developer machines
Developers add MCP servers to IDEs, desktop AI apps and command-line agents without telling security. Snyk says its scan data from nearly 10,000 developer environments found 4,524 unique MCP servers in active use.
Impact: Reviews and policies cover only the servers the team knows about; the rest run with user permissions and no owner.
Controls:
- Inventory MCP servers per machine from the client config files and from an endpoint tool that reports configured servers (Microsoft Defender for Endpoint documents local AI agent discovery that reports each agent's configured MCP servers).
- Give every approved server an owner and a review date, and compare the inventory with the catalog on a schedule.
- Block or flag servers not in the catalog using managed client settings.
Severity: high
Sources: Evo ADS MCP Governance Goes GA, Snyk (read ); What's new in Microsoft Defender for Endpoint (read ).
R-08: Token passthrough and missing audience validation
An MCP server accepts tokens that were issued for another service, or forwards the token it received to a downstream API. The MCP spec forbids both.
Impact: A token stolen from or meant for one service works against another, and downstream logs show the wrong caller. Advisories GHSA-rvq5-wwqv-78pq (TypeScript SDK) and GHSA-w4fh-qvv9-3v23 (Python SDK) describe SDK servers that could not check the audience.
Controls:
- Validate that each access token was issued for this server as its audience (RFC 8707) and reject others.
- Never forward the received token to an upstream API; obtain a separate token for downstream calls.
- After upgrading an SDK, turn on the audience check the patched version adds, since both advisories say upgrading alone changes nothing.
Severity: high
Sources: MCP Security Best Practices, 2026-07-28 revision (read ); MCP Authorization, 2026-07-28 revision (read ); GHSA-rvq5-wwqv-78pq: MCP TypeScript SDK bearer authentication audience (read ); GHSA-w4fh-qvv9-3v23: MCP Python SDK bearer-token audience (read ).
R-09: HTTP endpoint reachable without authentication
The protocol makes authorization optional, so a remote or HTTP-exposed MCP server can serve its tools to anyone who reaches it. Advisory CVE-2026-77244 (GHSA-wrhw-j3f9-8vc6) describes an mcp-atlassian token verifier that accepted any non-empty token over HTTP.
Impact: Anyone with network reach can call the server's tools using the credentials the server holds.
Controls:
- Require authentication on every HTTP endpoint that exposes non-public tools or data.
- Run the MCP server's HTTP transport only on loopback or a private network unless it sits behind authentication you control.
- Test that a request with an invalid or arbitrary token is refused.
Severity: high
Sources: OWASP MCP Security Cheat Sheet (read ); GHSA-wrhw-j3f9-8vc6: mcp-atlassian authentication bypass (CVE-2026-77244) (read ).
R-10: Confused deputy at an MCP proxy server
An MCP proxy that fronts a third-party API with one static client ID, allows dynamic client registration and skips per-client consent can be used to obtain authorization codes without the user's approval.
Impact: An attacker gains access to the third-party API as the user.
Controls:
- Store consent per user and per client_id on the server and check it before starting the upstream flow.
- Match redirect URIs by exact string and validate the OAuth state parameter on the callback.
- Set consent cookies with the __Host- prefix, Secure, HttpOnly and SameSite=Lax.
Severity: medium
Sources: MCP Security Best Practices, 2026-07-28 revision (read ).
R-11: Client credentials sent to a server-chosen authorization server
An MCP client that trusts server-supplied OAuth metadata can send stored credentials to an authorization server the server names. GHSA-6qxp-vccf-f47h (TypeScript SDK) and GHSA-vqqp-x5qm-5qp4 (FastMCP) describe this class of flaw.
Impact: A malicious or compromised server can receive a client secret or refresh token with no prompt to the user.
Controls:
- Bind stored credentials to the issuer that granted them and refuse to send them elsewhere (pass expectedIssuer or issuer where the SDK provides it).
- Upgrade MCP SDKs to the fixed versions named in the advisories and clear credentials saved without an issuer.
- Allow clients to connect only to servers on the approved list.
Severity: high
Sources: GHSA-6qxp-vccf-f47h: MCP TypeScript SDK OAuth client credentials (CVE-2026-104850) (read ); GHSA-vqqp-x5qm-5qp4: FastMCP client OAuth issuer binding (read ).
R-12: Over-broad token scopes
A server requests or holds a wider OAuth scope than its tools need, or all of a user's permissions through a shared token.
Impact: Any flaw or poisoned instruction in that server acts with the full scope, and one stolen token reaches many resources.
Controls:
- Request the narrowest scopes per tool and use per-server credentials, never one token shared across servers.
- Prefer short-lived tokens over long-lived personal access tokens.
- Handle insufficient_scope challenges by requesting only the added scope.
Severity: medium
Sources: MCP Security Best Practices, 2026-07-28 revision (read ); OWASP MCP Security Cheat Sheet (read ).
R-13: Authorization policy skipped on direct calls
A server applies its policy to the original component but a transform, template or direct lookup returns a different one without rechecking. FastMCP advisory GHSA-7xgj-8392-5q4r (23 Oct 2026) describes the case; mcp-atlassian GHSA-3r68-hf9h-887v describes a toolset authorization bypass.
Impact: A caller who knows an identifier can use a tool or read a resource that the configured policy denies.
Controls:
- Enforce authorization at the handler or server boundary, not only in a layer whose inputs a transform can change.
- Write tests that call every protected tool and resource directly, with a low-privilege identity.
- Upgrade to the fixed releases the advisories list.
Severity: medium
Sources: GHSA-7xgj-8392-5q4r: FastMCP post-transform authorization (read ); GHSA-3r68-hf9h-887v: mcp-atlassian toolset authorization bypass (read ).
R-14: Authorization server mix-up and unverified issuer
A client talks to more than one authorization server and accepts a response from the wrong one, or accepts metadata whose issuer does not match the server it asked.
Impact: A code or token meant for one authorization server is redeemed at another.
Controls:
- Record the issuer from validated metadata before redirecting the user and compare it on the response.
- Reject authorization server metadata whose issuer is not the expected origin (Python SDK 2.2.0 added this check on the legacy path).
- Prefer Client ID Metadata Documents over Dynamic Client Registration, which the 2026-07-28 revision deprecates.
Severity: medium
Sources: MCP Authorization, 2026-07-28 revision (read ); MCP Python SDK v2.2.0 release notes (read ).
R-15: State handle or message delivered to the wrong client
A server treats possession of a state handle as proof of identity, or a shared transport matches messages to clients by request id alone, so one caller's data reaches another. GHSA-jm63-cq47-j5jp describes the second case in the TypeScript server SDK.
Impact: One user's responses or state are exposed to, or changed by, another user.
Controls:
- Bind handles server-side to the authenticated user and use random, expiring values.
- Create the transport or server per request or per session, not once at startup, for HTTP servers.
- Verify every inbound request; never treat a handle as authentication.
Severity: medium
Sources: MCP Security Best Practices, 2026-07-28 revision (read ); GHSA-jm63-cq47-j5jp: MCP TypeScript server SDK cross-client messages (read ).
R-16: DNS rebinding against a local HTTP server
A web page the user visits uses a domain that later resolves to the user's own machine to talk to a local MCP server or developer tool that listens on HTTP.
Impact: The page can reach tools, tokens or files exposed by the local service. The Inspector's 2.12.0 release says a Host header check closes such a route to its API token and stored OAuth tokens.
Controls:
- Validate the Origin header on every Streamable HTTP request and answer an invalid one with 403, as the spec requires.
- Validate the Host header against an allow-list.
- Require an authorization token for local HTTP servers, or use stdio.
Severity: high
Sources: MCP Streamable HTTP transport, 2026-07-28 revision (read ); MCP Inspector 2.12.0 release notes (read ).
R-17: Local server listening on all interfaces
A server meant for the local machine binds to 0.0.0.0, so other hosts on the network can connect.
Impact: Anyone on the network can reach tools that were meant for one user.
Controls:
- Bind to 127.0.0.1 unless network access is intended, as the spec advises.
- Use stdio, or a Unix domain socket with restricted permissions, for local servers.
- Scan developer subnets for unexpected MCP listeners.
Severity: medium
Sources: MCP Streamable HTTP transport, 2026-07-28 revision (read ); MCP Security Best Practices, 2026-07-28 revision (read ).
R-18: Server-side request forgery through discovery and fetch tools
A client follows URLs supplied by a server (OAuth metadata, redirects), or a tool fetches URLs produced by a model, and the target is an internal address or a cloud metadata service.
Impact: Internal services and cloud credentials become reachable from the machine running the client or server. Inspector 2.15.0 extended its fetch guard to metadata addresses beyond 169.254.0.0/16.
Controls:
- Require HTTPS for OAuth URLs and block private, loopback and link-local ranges with a maintained library, not hand-written parsing.
- Validate redirect targets and pin DNS results between check and use.
- Send server-side fetches through an egress proxy that enforces destination policy.
Severity: high
Sources: MCP Security Best Practices, 2026-07-28 revision (read ); MCP Inspector 2.15.0 release notes (read ).
R-19: Credentials carried across cross-origin redirects
An HTTP client follows a redirect to another origin and sends Authorization headers or cookies with it. Advisories for the Python SDK (GHSA-5h93-6whr-6q8j) and the TypeScript client SDK (GHSA-6prh-2h8m-c8cw) describe the pattern.
Impact: A server or an intermediary can collect credentials meant for another host.
Controls:
- Follow redirects only within the same scheme, host and port, as Python SDK 2.2.0 does by default.
- Drop Authorization and cookie headers on any cross-origin redirect.
- Upgrade to the SDK versions named in the advisories.
Severity: medium
Sources: GHSA-5h93-6whr-6q8j: MCP Python SDK cross-origin redirects (read ); GHSA-6prh-2h8m-c8cw: MCP TypeScript client SDK cross-origin redirects (read ); MCP Python SDK v2.2.0 release notes (read ).
R-20: Remote server without TLS or with unverified identity
A client connects to a remote MCP server over plain HTTP, or without checking who the server is.
Impact: Traffic and tokens can be read or changed in transit, and a different server can answer.
Controls:
- Use TLS for every remote Streamable HTTP connection.
- Keep client runtimes current: Inspector 2.13.0 notes that certificate checks rely on the Node.js runtime and names patched Node.js releases after an October 2026 CA issue.
- Reject http URLs for OAuth endpoints except loopback addresses during development.
Severity: medium
Sources: OWASP MCP Security Cheat Sheet (read ); MCP Inspector 2.13.0 release notes (read ).
R-21: Unbounded requests and sessions exhaust a server
An HTTP server accepts requests or sessions without limits. GHSA-46jr-4wx8-v453 (TypeScript SDK) and GHSA-84m7-p3x7-pcfv (Python SDK) describe memory and session exhaustion.
Impact: A single unauthenticated client can stop the service. Impact is availability only.
Controls:
- Set request size, session count and idle-timeout limits (Python SDK 2.2.0 expires idle legacy sessions after 30 minutes and caps them at 10,000).
- Apply rate limits and quotas per tenant.
- Authenticate requests before they reach the SDK.
Severity: low
Sources: GHSA-46jr-4wx8-v453: MCP TypeScript SDK memory exhaustion (read ); GHSA-84m7-p3x7-pcfv: MCP Python SDK session accumulation (read ); MCP Python SDK v2.2.0 release notes (read ).
R-22: Unrestricted outbound access from server processes
A server process can open connections to any host, so a flaw or a malicious package can send data anywhere.
Impact: Stolen data leaves the machine without a block. The altered SP-API package described by Knostic sent credentials to a hardcoded IP.
Controls:
- Disable network access for servers that do not need it and allow-list destinations for those that do.
- Log and alert on connections from MCP server processes to new destinations.
- Use an egress proxy for server-side deployments.
Severity: medium
Sources: Local Server Security, modelcontextprotocol.io (read ); Repackaged Amazon SP-API MCP Sends App Secrets to an Undisclosed IP, Knostic (read ).
R-23: Poisoned tool description
Instructions hidden in a tool description steer the model, which reads the description to decide how to call the tool. Knostic described a package on 12 Nov 2026 whose description tells the agent to fetch a GitHub token without asking the user.
Impact: The agent takes an action the user did not request, such as reading a credential.
Controls:
- Review the full text of every tool description and parameter field before a server is approved.
- Hash and pin the reviewed definitions and alert on change.
- Scan descriptions with a tool built for the purpose (the OWASP cheat sheet names mcp-scan) and keep a human approval step for sensitive calls.
Severity: high
Sources: OWASP MCP Security Cheat Sheet (read ); When an MCP Tool Asks for Your GitHub Token, Knostic (read ); AI tool poisoning through MCP tool descriptions, CrowdStrike (read ).
R-24: Tool shadowing across servers
One server's tool text manipulates how the agent uses tools from another, trusted server, because the model sees all connected descriptions at once.
Impact: A low-trust server can alter how a high-trust one is used, including which data is sent where.
Controls:
- Treat each server as its own security domain and keep sensitive servers apart from general-purpose ones.
- Monitor for cross-server data flows, such as one server's credentials appearing in another's calls.
- Limit how many servers a single agent session may load.
Severity: medium
Sources: OWASP MCP Security Cheat Sheet (read ).
R-25: Hostile content in schemas and return values
Instructions can sit in parameter names, types, defaults and the values a tool returns, not only in the description field.
Impact: Review that checks only the description misses the other fields the model reads.
Controls:
- Inspect every field of the definition, including inputSchema and outputSchema.
- Set additionalProperties to false and use pattern constraints on string fields.
- Validate and sanitize tool outputs before they re-enter model context.
Severity: medium
Sources: OWASP MCP Security Cheat Sheet (read ); MCP Tools, 2026-07-28 revision (read ).
R-26: Annotations trusted as enforcement
A client lets a server's readOnlyHint or destructiveHint decide how much approval to ask for. The spec says clients must consider annotations untrusted unless they come from trusted servers.
Impact: A flipped hint can change approval behavior with no visible change to the description.
Controls:
- Treat annotations as hints only and decide approval from your own policy per tool.
- Include annotations in the pinned hash of each tool definition.
- Require confirmation for sensitive reads, writes and irreversible actions whatever the label says.
Severity: medium
Sources: MCP Tools, 2026-07-28 revision (read ); OWASP MCP Security Cheat Sheet (read ).
R-27: Prompt injection through tool results
A tool returns text, such as a web page or ticket, that contains instructions the model then follows.
Impact: An approved server can still cause unapproved actions through the content it returns.
Controls:
- Treat every tool response as untrusted data, including responses from approved servers.
- Enforce authorization and validate follow-up tool calls in application code, regardless of the model's interpretation.
- Extract structured fields from retrieval tools instead of passing raw pages.
Severity: high
Sources: OWASP MCP Security Cheat Sheet (read ).
R-28: Server-supplied schemas that exhaust or confuse clients
A client evaluates patterns or fetches references in a schema a server supplies. Inspector 2.14.0 now checks schema patterns in bounded time, and Python SDK advisory GHSA-rwrf-2pqf-9j8j describes a client fetching server-chosen $ref URLs.
Impact: A hostile server can slow or break a client, or cause it to make requests it should not.
Controls:
- Evaluate server-supplied patterns with a linear-time matcher and limits.
- Do not resolve remote references from schemas supplied by untrusted servers.
- Keep MCP clients and the Inspector on current releases.
Severity: low
Sources: MCP Inspector 2.14.0 release notes (read ); GHSA-rwrf-2pqf-9j8j: MCP Python SDK server-chosen $ref URLs (read ).
R-29: Local server runs with the user's full privileges
A local MCP server is an ordinary process launched by the host application. It inherits the user's environment variables and can read anything the account can read.
Impact: A flawed or malicious server reaches SSH keys, cloud credentials, browser profiles and the home directory.
Controls:
- Run local servers in a container or sandbox with minimal default privileges.
- Restrict filesystem access to the directories the server needs.
- Run servers under a separate account or workspace where the client allows it.
Severity: high
Sources: Local Server Security, modelcontextprotocol.io (read ); MCP Security Best Practices, 2026-07-28 revision (read ).
R-30: Malicious startup command in configuration
A client configuration or one-click install carries a launch command that runs code. The spec lists a malicious startup command as a local-server compromise route.
Impact: Arbitrary code runs with the client's privileges the moment the server starts.
Controls:
- Show the exact command, with arguments and without truncation, before any server is added.
- Flag commands that use sudo, delete files, use network tools or reach SSH and home directories.
- Distribute approved configurations through managed settings (VS Code allowedMcpServers, Claude Code managed-mcp.json).
Severity: high
Sources: MCP Security Best Practices, 2026-07-28 revision (read ); Connect Claude Code to tools via MCP, Claude Code docs (read ).
R-31: Command injection through arguments or URL opening
Text from a model, a tool argument or a server-supplied OAuth authorization URL reaches a shell. The Inspector's 2.12.0 notes say a remote server's authorization URL could previously run commands through the opener on Windows and WSL.
Impact: Code runs on the machine with the user's privileges.
Controls:
- Allow only http and https schemes for authorization URLs and never open URLs through a shell.
- Never pass raw shell commands or unsanitized paths from tool arguments.
- Validate tool inputs against strict schemas and allow-lists.
Severity: high
Sources: MCP Security Best Practices, 2026-07-28 revision (read ); MCP Inspector 2.12.0 release notes (read ); OWASP MCP Security Cheat Sheet (read ).
R-32: Path traversal and arbitrary file read in file tools
A tool that reads or uploads files accepts a path without limiting it to an intended directory. 14 of the 25 mcp-atlassian advisories published on 22 Sep 2026 concern file read through attachment tools.
Impact: Server credentials and local files can be read and sent out through the tool.
Controls:
- Resolve paths on the server and reject any that leave an allowed directory.
- Run file tools in a sandbox that mounts only the needed folders.
- Upgrade mcp-atlassian to 0.22.0 or later.
Severity: high
Sources: GHSA-93xw-j965-9mx3: mcp-atlassian arbitrary file read (read ); OWASP MCP Security Cheat Sheet (read ).
R-33: Project configuration from a cloned repository
A repository carries MCP configuration that a client could load automatically. Claude Code's docs say a cloned repository cannot approve its own servers and that approval settings committed to the project are ignored in an untrusted folder.
Impact: Opening a repository could start a server chosen by its author.
Controls:
- Do not auto-enable project servers: leave enableAllProjectMcpServers unset or false and review each project server.
- Use workspace trust and require approval for project-scoped servers.
- Lock server sets with managed-mcp.json and allowedMcpServers or deniedMcpServers.
Severity: high
Sources: Connect Claude Code to tools via MCP, Claude Code docs (read ); AI settings for enterprise, Visual Studio Code docs (read ).
R-34: Tool calls auto-approved without full arguments
A client approves tool calls automatically, or shows only a tool name, so the user never sees what is about to run.
Impact: A poisoned description or injected content can trigger destructive or data-sharing actions without anyone noticing.
Controls:
- Require explicit confirmation for destructive, financial and data-sharing operations and show full parameters.
- Never auto-approve tool calls in multi-server setups.
- Make sure the confirmation interface cannot be satisfied by text the model generates.
Severity: high
Sources: OWASP MCP Security Cheat Sheet (read ); MCP Tools, 2026-07-28 revision (read ).
R-35: Developer tools that spawn processes on a port
A developer tool such as an MCP inspector can start stdio servers on request, and its API token is what protects that ability from other callers.
Impact: A weak guard turns a testing tool into a way to run commands. The Inspector's own docs say its web backend can spawn processes and that stdio servers run as the user.
Controls:
- Keep the Inspector on a current version; releases 2.12.0, 2.14.0 and 2.15.0 carry security fixes.
- Do not disable its authentication (DANGEROUSLY_OMIT_AUTH) outside an isolated test setup.
- Bind it to loopback and never expose its port.
Severity: medium
Sources: MCP Inspector security documentation (read ); MCP Inspector 2.12.0 release notes (read ).
R-36: Secrets inherited through the environment
A server started by the client inherits the environment of the host process, which often holds cloud keys and tokens.
Impact: A server that needs one key can read all of them.
Controls:
- Start servers with a minimal environment and pass only the variables each one needs.
- Use separate credentials per server with the least privilege.
- Keep secrets in an OS credential store rather than in the shell profile.
Severity: high
Sources: Local Server Security, modelcontextprotocol.io (read ); OWASP MCP Security Cheat Sheet (read ).
R-37: Tokens stored in plaintext
A server or client saves OAuth tokens in a file with loose permissions or in plain text. mcp-atlassian advisories GHSA-g5xv-mhgm-v5f6 and GHSA-4596-2p6p-28cv describe this, and the Inspector's docs say its secrets fall back to a plaintext file when no OS keychain exists.
Impact: Any local process or user that can read the file gets the tokens.
Controls:
- Use the OS credential store (macOS Keychain, Windows Credential Manager, Linux Secret Service).
- Set file permissions to the owner only where files are unavoidable.
- Never store tokens in MCP config files, which the OWASP cheat sheet also says.
Severity: medium
Sources: OWASP MCP Security Cheat Sheet (read ); GHSA-g5xv-mhgm-v5f6: mcp-atlassian plaintext OAuth token storage (read ); MCP Inspector security documentation (read ).
R-38: Data exfiltration through legitimate tool calls
Injected instructions encode sensitive data into ordinary-looking calls, such as search queries or email subjects.
Impact: Data leaves through channels that policy allows.
Controls:
- Monitor for credentials or sensitive values from one server appearing in calls to another.
- Restrict which tools can send data outside the organization and require approval for them.
- Limit the data each server can read in the first place.
Severity: high
Sources: OWASP MCP Security Cheat Sheet (read ).
R-39: Sensitive data requested through form elicitation
A server uses form-mode elicitation to ask the user for a password, API key or token, which passes through the client.
Impact: Secrets pass through the client and its logs. The spec forbids it.
Controls:
- Reject servers that request secrets in form mode and use URL mode for credential steps.
- Show which server is asking and let the user decline.
- Review elicitation requests during server vetting.
Severity: medium
Sources: MCP Elicitation, 2026-07-28 revision (read ).
R-40: No record of tool calls
Tool invocations are not logged with their parameters, user and time, so there is nothing to investigate after an incident.
Impact: A misuse or a poisoned call cannot be reconstructed, and anomalies go unseen.
Controls:
- Log every tool invocation with full parameters, user context and timestamp.
- Send the logs to a SIEM and alert on new tools, admin-level queries and unusual call rates.
- Keep the logs long enough to cover an investigation window you set.
Severity: medium
Sources: OWASP MCP Security Cheat Sheet (read ); MCP Security Best Practices, 2026-07-28 revision (read ).
R-41: Secrets and personal data written into logs
Logging full parameters also records secrets and personal data that appear in arguments and results.
Impact: The log store becomes a second place to steal credentials from.
Controls:
- Redact secrets and personal data before storing tool-call logs.
- Restrict who can read the logs and set a retention period.
- Test the redaction rules with sample credentials.
Severity: medium
Sources: OWASP MCP Security Cheat Sheet (read ).
R-42: Protected data returned through resources and templates
Resources and resource templates expose data by URI, and a template can retrieve a resource that a rule denied.
Impact: Data outside a caller's rights is returned. FastMCP's GHSA-7xgj fix makes a denied concrete resource shadow a matching template.
Controls:
- Check authorization for the final resource that is returned, not the template.
- Avoid overlapping proxy templates for protected resources.
- Test reads for denied URIs through every route.
Severity: medium
Sources: GHSA-7xgj-8392-5q4r: FastMCP post-transform authorization (read ); MCP Tools, 2026-07-28 revision (read ).
Download and cite
Download the MCP Risk Register as CSV or JSON. Cite it as: Cite assets as: MCP Server Security, "<asset name>", edition 16 Nov 2026, https://mcpservercybersecurity.com/<asset path>/, licensed CC BY 4.0.