Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify exposed MCP HTTP endpoint
-
DeliverySend oversized/streamed request body
-
ExploitServer buffers body without size cap
-
ExecutionProcess memory exhausted
-
ImpactServer crashes or hangs (DoS)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires an MCP Python SDK server exposing an HTTP-based transport - specifically the Streamable HTTP session manager, the SSE message endpoint, or the OAuth authorization-server routes - reachable by the attacker, running an affected version (before 1.29.1, or 2.0.0a1 through 2.0.1), with NO effective upstream request-size limit (e.g., no reverse proxy/gateway body cap). Exploitation is explicitly NOT possible against stdio-only servers, nor where an upstream component already enforces a body-size limit. Applications that call StreamableHTTPServerTransport directly are responsible for their own limit and may remain exposed even after SDK upgrade if they do not set one. No authentication (PR:N), user interaction, or special attacker privileges are needed against a qualifying default HTTP deployment. |
| Impact | This is a genuine but bounded-priority issue rather than a critical emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N) is credible: an unauthenticated remote client over the network can trigger the flaw with low complexity against an affected HTTP-exposed endpoint, and the C:N/I:N/A:H profile correctly reflects a pure availability (memory-exhaustion / crash, CWE-770) impact with no confidentiality or integrity loss. The real-risk ceiling is lowered by meaningful scope constraints the description makes explicit: stdio-only servers are unaffected, and any deployment behind an upstream proxy or gateway enforcing a request-size limit is also unaffected - a very common production pattern. No EPSS score, no CISA KEV listing, and no public POC were provided in the input; by the precision rules this means no public exploit is identified at analysis time and exploitation is not confirmed active. Note the apparent conflict is only superficial: the network vector is real, but the practical attack surface is limited to SDK HTTP transports (Streamable HTTP session manager, SSE message endpoint, OAuth authorization-server routes) that lack an effective upstream body-size cap. Bottom line: patch-worthy availability bug, straightforward to exploit where exposed, but not a drop-everything incident absent evidence of in-the-wild use. |
| Exploit ScenarioDerived | An attacker locates an internet-reachable MCP server built on the Python SDK using the Streamable HTTP transport (or SSE/OAuth routes) with no upstream body-size limit, then POSTs a very large declared or streamed request body to the message endpoint. Because the body is buffered in full before parsing - consuming multiple times its size in process memory - repeated requests exhaust RAM and crash or hang the server. No authentication or user interaction is required; no public exploit code was identified at the time of analysis, though the fixing commits are public. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Unbounded HTTP request-body buffering in the Model Context Protocol Python SDK (the 'mcp' package) before 1.29.1 and in 2.0.0a1 through 2.0.1 allows unauthenticated remote attackers who can reach an exposed HTTP transport endpoint to exhaust server memory and potentially terminate the process. The Streamable HTTP session manager, the SSE message endpoint, and the OAuth authorization-server routes read complete request bodies without any maximum-size check, so a single large declared or streamed body can consume multiple times its own size in process memory and repeated requests can drive sustained memory pressure. Per the CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) the impact is availability-only, and no public exploit code was identified at time of analysis; stdio-only servers and deployments behind an effective upstream request-size limit are not affected. This is a genuine but bounded-priority availability issue - the fix is a vendor-released patch in 1.29.1 and 2.1.0 that enforces a 4 MiB default body cap and returns HTTP 413, and the primary residual exposure is default HTTP deployments with no reverse-proxy or gateway body limit.
RemediationAI
Vendor-released patch: upgrade to mcp 1.29.1 (1.x line) or 2.1.0 (2.x line); the advisory and release artifacts are at https://github.com/modelcontextprotocol/python-sdk/security/advisories/GHSA-fmmv-w9g8-j3gc, https://github.com/modelcontextprotocol/python-sdk/releases/tag/v1.29.1, and https://github.com/modelcontextprotocol/python-sdk/releases/tag/v2.1.0. The patched SDK applies a 4 MiB default limit to Streamable HTTP POST bodies and returns HTTP 413 before JSON parsing or session creation; if your application legitimately exchanges larger MCP messages, set an explicit positive limit via max_request_body_size on run() or streamable_http_app() (for example max_request_body_size=8 * 1024 * 1024), but keep the smallest value your traffic actually requires, since raising it restores a larger per-request memory amplification factor. Applications that use StreamableHTTPServerTransport directly must implement their own body-size cap, as the SDK upgrade alone will not protect them. If immediate upgrade is not possible, the highest-value compensating control is to enforce a request-body size limit at the edge - for example an nginx client_max_body_size, an API gateway body cap, or equivalent WAF rule - because the advisory states deployments with an effective upstream request-size limit are not affected; the trade-off is that a too-tight edge limit silently rejects legitimate large MCP or OAuth payloads with 413 responses, so tune it above your largest valid message. Additionally, restrict network reachability of the Streamable HTTP, SSE, and OAuth authorization-server endpoints to trusted clients or networks (note this is not authentication and does not address an insider or a reachable-network attacker), and add per-connection memory limits, request rate limiting, and process-level memory/watchdog caps to reduce the blast radius and speed recovery; these measures lower the likelihood and impact of repeated exhaustion but do not remove the underlying unbounded-allocation flaw, so they should be treated as temporary mitigations until patching.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The Model Context Protocol (MCP) Python SDK implements MCP servers and clients over several transports, including stdio and HTTP-based transports. The vulnerable paths are the Streamable HTTP session manager (src/mcp/server/streamable_http_manager.py), the SSE message endpoint, and the OAuth authorization-server routes, all of which buffered full HTTP request bodies into memory without consulting a configured ceiling. The root cause class is CWE-770 (Allocation of Resources Without Limits or Throttling): the server allocates and retains attacker-controlled amounts of memory proportional to (and per the advisory description, a multiple of) the declared or streamed body size, with no size check before the body is read, parsed as JSON, or used to create a session. Because the request is processed prior to any authentication on these routes - consistent with the PR:N vector and the description's 'unauthenticated remote client' - each request is a cheap, repeatable allocation trigger, and concurrency multiplies the effect. The upstream fix introduces DEFAULT_MAX_REQUEST_BODY_SIZE with a 4 MiB default, threads a max_request_body_size parameter through run(), streamable_http_app(), and the session manager, and rejects oversized bodies with HTTP 413 before JSON parsing or session creation (see commit 03aaebd3aadb2567878dd811cb1f141454e8a080 and the related commits 4dc224fab201bdef2fd5a065976b7ca31420187c, 57394b0548d1e2dc2dce8d67d84985769df3b8bb, 5f0b6af9f2b0aad3be3ba5cbfe80a9e4ea32e189). The affected CPE is cpe:2.3:a:modelcontextprotocol:python-sdk:*:*:*:*:*:*:*:*, reflecting that the SDK is distributed as a Python package rather than as a versioned network appliance.
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:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Unauthenticated network client sends an oversized body with no special conditions on a default HTTP transport (AV:N/AC:L/PR:N/UI:N); impact is availability-only memory exhaustion (A:H, C:N/I:N).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
The Model Context Protocol Python SDK is the official Python SDK for Model Context Protocol servers and clients. In mcp versions before 1.29.1 and from 2.0.0a1 through 2.0.1, the Streamable HTTP session manager, SSE message endpoint, and OAuth authorization-server routes buffer complete HTTP request bodies without enforcing a maximum size. An unauthenticated remote client able to reach an affected endpoint can send a large declared or streamed request body that consumes multiple times the body size in process memory and can repeatedly exhaust memory or terminate the server. Stdio-only servers and deployments with an effective upstream request-size limit are not affected, and applications that use StreamableHTTPServerTransport directly remain responsible for enforcing their own limit. The standard SDK server applications and session managers are fixed in versions 1.29.1 and 2.1.0.
Technical POC Analysis
CWE-770 (Allocation of Resources Without Limits or Throttling).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A widely used Python library for connecting AI agents to tools and data over HTTP, the Model Context Protocol SDK (mcp package), mishandles incoming request bodies in a way that lets any unauthenticated network user exhaust server memory and crash the process. Organizations running internet- or partner-reachable MCP HTTP endpoints - including Streamable HTTP, SSE messaging, and OAuth authorization routes - could see repeated service outages of AI-integrated applications, though confidentiality and integrity of data are not affected. Leadership should care because the affected component sits in the path of customer-facing AI features, and the barrier to disruption is low: no credentials and no exploit tooling are required.
No vendor-released patch identified at time of analysis based on the structured patch field; the advisory text references fix versions 1.29.1 and 2.1.0, which should be confirmed against the current vendor advisory. Interim mitigations: enforce a hard maximum request-body size at an upstream reverse proxy, API gateway, or load balancer in front of every exposed MCP HTTP endpoint; avoid direct internet exposure of the Streamable HTTP, SSE message, and OAuth authorization-server routes and limit reachability to trusted clients; run stdio-only transport where HTTP is not required (stdio-only servers are not affected); apply container or process memory limits with restart policies so memory exhaustion recycles the process instead of destabilizing the host; and alert on abnormal memory growth and repeated process restarts on affected services.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
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
Missing authorization in the MCP Python SDK (the `mcp` PyPI package) versions 1.23.0 through 1.27.1 lets any authenticat
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-101514
NVD
CVE.org
EPSS
GitHub
Exploit-DB