Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInfluence trusted endpoint's redirect target
-
DeliveryEndpoint returns cross-origin redirect
-
ExploitMCP client follows redirect off-origin
-
ExecutionCustom credential header and body forwarded
-
ImpactAttacker captures API key material
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V14 - Data Protection Data exposure prevention
MITRE ATT&CK
2 techniques across 2 tactics: Collection, Discovery The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires a victim running the SDK as an MCP HTTP client through one of streamable_http_client, streamablehttp_client, sse_client, ClientSessionGroup with HTTP parameters, the OAuth client providers, or the internal create_mcp_http_client helper, in versions 1.8.0-1.29.1 or 2.0.0-2.1.1 where follow_redirects is enabled (the SDK default in those versions, or a client the caller passed with follow_redirects=True). The client must also set custom credential headers (e.g. X-API-Key), and the attacker must be able to make a trusted endpoint issue a cross-origin redirect to an origin they control (a stale redirect to a lapsed domain, a misrouted proxy rule, or attacker-influenced redirect logic). Clear LIMITING factors stated by the vendor: a lone Authorization bearer header is NOT exposed (httpx drops it on cross-origin redirects); the request body is only re-sent on 307/308 responses; MCP servers, stdio clients, and clients supplied with follow_redirects left at its default False are NOT affected; and a malicious MCP server gains nothing since it already receives the client's requests directly. |
| Impact | This is a genuine but conditional credential-disclosure issue (CVSS 5.9, Medium), not a drop-everything emergency. The CVSS vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N is internally consistent with the mechanism: network-reachable (AV:N), no authentication on the victim client side (PR:N), no user interaction (UI:N), and high confidentiality impact (C:H) with no integrity or availability impact (I:N/A:N). The AC:H is justified - exploitation is gated on an attacker's ability to make a trusted endpoint redirect to an origin they control, a precondition outside the attacker's direct control. There is no EPSS score or SSVC decision framework in the supplied data, and the vulnerability is NOT in CISA KEV, so there is no public evidence of active exploitation. The vuln.today priority is 'this_month', consistent with a Medium-severity, patch-available issue rather than an urgent one. The references are the GHSA advisory, fix PRs, commits and release tags - these are remediation artifacts, not exploit code, so no public exploit is identified. Net: a real issue worth patching on a normal cadence for anyone running affected MCP HTTP client code, but its impact is bounded to deployments that both carry custom credential headers and trust an endpoint whose redirect target can be influenced. |
| Exploit ScenarioDerived | An organization runs an MCP client built on the affected SDK, configured with a custom credential header such as X-API-Key to reach a trusted MCP server over HTTP. That server (or a proxy in front of it) is made to issue a cross-origin redirect - for example a stale redirect pointing at a lapsed domain an attacker has since registered - and the client dutifully follows it, forwarding the X-API-Key header (and, on a 307/308, the full request body) to the attacker-controlled origin, who captures the credential. No public exploit code is identified at time of analysis; exploitation also depends on the attacker-controllable redirect precondition rather than a direct flaw the attacker can trigger unaided. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Cross-origin redirect handling in the Model Context Protocol Python SDK (published on PyPI as mcp) leaks caller-supplied custom credential headers, and on 307/308 responses the request body, to any host a trusted MCP endpoint redirects to. Affected are HTTP client paths using streamable_http_client, streamablehttp_client, sse_client, ClientSessionGroup with HTTP server parameters, the OAuth client providers, or the internal create_mcp_http_client helper in versions 1.8.0 through 1.29.1 and 2.0.0 through 2.1.1, where redirect following was enabled by default or by a caller-supplied client with follow_redirects=True. Impact is conditional: a lone Authorization bearer header is dropped by the HTTP library on cross-origin hops, the body is only re-sent on 307/308, MCP servers and stdio clients are unaffected, and a malicious MCP server gains nothing because it already receives the requests directly, so exploitation depends on an attacker influencing where a trusted endpoint redirects (stale redirect to a lapsed domain, misrouted proxy rule, attacker-influenced redirect logic). No public exploit code or CISA KEV entry was identified at time of analysis, and the vendor-released fix is available in 1.30.0 (1.x) and 2.2.0 (2.x).
RemediationAI
Vendor-released patch: upgrade to mcp 1.30.0 (1.x branch) or 2.2.0 (2.x branch) or later; no code changes are required. After upgrading, the transports and the OAuth providers follow a redirect only when it stays on the endpoint's origin (same scheme, host and port, or an http to https upgrade on the same host) and keeps the request method; any other redirect is not followed and the request fails with an error naming the target (MCPError on 2.x, httpx.HTTPStatusError on 1.x). Be aware of two behavioral side effects: deployments that legitimately reach their server through a cross-host redirect (including servers that require no credentials) will stop connecting until the endpoint URL is set to the redirect's final target, and code calling create_mcp_http_client directly now receives the redirect response because that helper no longer enables redirect following. If upgrading is not yet possible, supply your own HTTP client with follow_redirects left at False - via http_client= on streamable_http_client, or httpx_client_factory= on sse_client and streamablehttp_client; ClientSessionGroup exposes no such parameter, so no client-side workaround is available there. Rotate any credentials (custom API key headers) that a client may already have carried across a redirect to a host you do not control. Details and diff: https://github.com/modelcontextprotocol/python-sdk/pull/3397, https://github.com/modelcontextprotocol/python-sdk/pull/3448, https://github.com/modelcontextprotocol/python-sdk/commit/2106335745563b2321b8c73fef2c12903d00aa6e, https://github.com/modelcontextprotocol/python-sdk/commit/c6762e821c527925f0b617db216d00fbd1d0bf99.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in pypi, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The MCP Python SDK implements the client side of the Model Context Protocol over HTTP via Streamable HTTP and Server-Sent Events transports built on the httpx/httpx2 AsyncClient. In the affected branches the SDK constructed its default HTTP client with follow_redirects=True (and did not consult or override that setting), so when a configured MCP endpoint answered with a redirect to a different origin, the transport replayed the request there: custom headers set on the client, such as an X-API-Key, were forwarded to the new host, and on 307/308 responses the body was re-sent as well. The SDK's OAuth client providers performed discovery, registration and token requests through the same client paths and followed redirects identically. This is a CWE-200 information-disclosure class issue rooted in redirect-following policy rather than in memory safety or injection; the trigger is an origin change on an HTTP redirect response, and the vendor notes that httpx already strips a lone Authorization bearer header on cross-origin redirects, so only additional custom headers (and 307/308 bodies) are exposed. The fix replaces blanket redirect following with a same-origin policy: only redirects that keep scheme, host and port (plus an http to https upgrade on the same host) and preserve the method are followed, and create_mcp_http_client no longer enables redirect following at all.
Know when Python Sdk gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N
Network-reachable with no client authentication (AV:N/PR:N/UI:N); AC:H because it depends on an attacker-influenceable cross-origin redirect from a trusted endpoint; only credential confidentiality is impacted (C:H/I:N/A:N).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
The Model Context Protocol Python SDK is the official Python SDK for Model Context Protocol servers and clients. From 1.8.0 until 1.30.0 and 2.2.0, streamable_http_client, streamablehttp_client, sse_client, ClientSessionGroup, OAuth, and create_mcp_http_client client paths enable follow_redirects and follow redirects to a different origin, forwarding caller-supplied custom credential headers and, for 307 or 308 responses, the request body. An attacker who can influence a trusted endpoint's redirect destination can receive that material. This issue is fixed in versions 1.30.0 and 2.2.0.
Blast Radius
ecosystem impact- 84 pypi packages depend on mcp (66 direct, 18 indirect)
Ecosystem-wide dependent count for version 2.0.0.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
More in Python Sdk
View allCross-session message injection in the MCP Python SDK (the 'mcp' package on PyPI) prior to 1.27.2 allows an authenticate
Resource-confusion in the Model Context Protocol Python SDK (pip package mcp) causes server-side bearer authentication t
Client-side server-side request forgery and denial of service in the official Model Context Protocol Python SDK: when a
Missing authorization in the MCP Python SDK (the `mcp` PyPI package) versions 1.23.0 through 1.27.1 lets any authenticat
Unbounded HTTP request-body buffering in the Model Context Protocol Python SDK (the 'mcp' package) before 1.29.1 and in
Cross-origin WebSocket hijacking in the Model Context Protocol Python SDK (mcp on PyPI) before 1.28.1 lets a remote web
Unbounded server-side memory growth in stateful Streamable HTTP servers built on the MCP Python SDK (the 'mcp' package o
EUVD-2026-111367
GHSA-5h93-6whr-6q8j
NVD
CVE.org
EPSS
Exploit-DB