Skip to main content

MCP Python SDK EUVDEUVD-2026-101514

| CVE-2026-109527 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-10-14 GitHub_M
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify exposed MCP HTTP endpoint
  2. Delivery
    Send oversized/streamed request body
  3. Exploit
    Server buffers body without size cap
  4. Execution
    Process memory exhausted
  5. Impact
    Server 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.7% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

python-sdk 2.0.0a1, < 2.1.0
python-sdk < 1.29.1

Affected Packages

euvd python_sdk fix: 1.29.1, 2.1.0

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

Vendor (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

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).

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Red Hat 7.5 HIGH

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Oct 14, 2026 - 19:35 EUVD
CVE Published
Oct 14, 2026 - 17:52 cve.org
HIGH 7.5

DescriptionCVE.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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.7%
Top 48% exploitable
Prevalence
Medium
official MCP Python SDK, growing AI-tooling adoption but HTTP-exposed subset only
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.7%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Medium

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy