Skip to main content

MCP Context Forge EUVDEUVD-2026-78933

| CVE-2026-53710 CRITICAL
Code Injection (CWE-94)
2026-09-15 GitHub_M GHSA-xm98-3vcf-fph7 PYSEC-2026-3862
10.0
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach unauthenticated HTTP/SSE sandbox endpoint
  2. Delivery
    Submit execute_code tools/call with obfuscated payload
  3. Exploit
    Bypass validate_code via runtime-constructed dunders
  4. Execution
    Traverse class hierarchy via raw getattr to subprocess.Popen
  5. Persist
    Execute OS commands as server process
  6. Impact
    Filesystem access or network pivot from host

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires that the python_sandbox_server subproject (mcp-servers/python/python_sandbox_server) be deployed and its execute_code MCP tool reachable - specifically over the HTTP/SSE transport, which the advisory states can be exposed with NO authentication layer, allowing any client reaching the endpoint to submit payloads via tools/call. Limiting factors: this does NOT affect the core Context Forge gateway or proxy; stdio-only deployments have greatly reduced network reachability and are not remotely exploitable in the same way; and the affected component is an optional sub-server that an operator must have registered/exposed. Escalation to filesystem compromise or network pivoting additionally depends on containerized deployments with host mounts or internal network reachability. All affected in versions <= 1.0.1; fixed in 1.0.2.

Impact

This is a genuine high-priority issue where the multiple signals largely agree. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H = 10.0) describes unauthenticated remote code execution, and the GHSA advisory confirms a WORKING proof-of-concept that walks the Python class hierarchy through the exposed getattr, reaches subprocess.Popen, and runs OS commands - so 'publicly available exploit code exists.' There is no CISA KEV listing and no EPSS score in the input, so there is no evidence of active in-the-wild exploitation yet; treat this as exploit-code-available rather than actively-exploited. The one signal to scrutinize is the S:C scope-change and the 10.0 rating: the described impact is code execution within the server process, and scope change is only realized in the secondary scenarios the advisory itself frames conditionally ('containerized deployments with host mounts or internal network reachability'). Assessed as in-process RCE the base is 9.8 (S:U), still critical. Crucially, the score assumes the python_sandbox_server subproject is deployed over HTTP/SSE without authentication - stdio-only deployments have sharply reduced reachability, and the core Context Forge gateway/proxy is not directly affected, so real-world exposure is narrower than the raw 10.0 suggests.

Exploit ScenarioDerived

An attacker who can reach the python_sandbox_server's HTTP/SSE endpoint (exposed with no authentication layer) submits a payload to the execute_code MCP tool via tools/call. The payload constructs dunder names at runtime to evade the validate_code substring blocklist, uses the raw getattr in safe_builtins to traverse the class hierarchy to subprocess.Popen, and runs arbitrary OS commands as the server process. A working PoC is published in the GHSA advisory (marker command output 'IBM_SANDBOX_POC_PASS').

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.8% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 16, 2026

Sandbox escape in the python_sandbox_server subproject of IBM MCP Context Forge (versions up to and including 1.0.1) allows a remote, unauthenticated attacker to execute arbitrary OS commands with the privileges of the server process. The vulnerable execute_code MCP tool can be exposed over the HTTP/SSE transport without any authentication layer, so any client that can reach the endpoint can submit a payload via tools/call; publicly available exploit code exists (the vendor advisory includes a working local PoC with artifact hashes). Exploitation is conditional on the optional python_sandbox_server being deployed and network-reachable - the core Context Forge gateway and proxy components are not directly affected, and stdio-only deployments are not remotely exposed - but when reachable it is a critical-severity, unauthenticated code-execution path.

RemediationAI

Vendor-released patch: upgrade mcp-contextforge-gateway to 1.0.2 or later (pip install --upgrade mcp-contextforge-gateway==1.0.2), which is the release containing commit 63a2900e6301b9c8a483a38d3737a1beb3a7ce89; that commit removes raw getattr/setattr/hasattr from safe_builtins, installs RestrictedPython _getattr_/_setattr_ guards with a safe-dunder allowlist, replaces the substring dunder check with AST-based analysis, and introduces a bearer-token middleware (SANDBOX_API_TOKEN) plus starlette/uvicorn for HTTP transport. If immediate upgrade is not possible, do not deploy python_sandbox_server over HTTP/SSE - run it stdio-only, since the advisory states the unauthenticated exposure is specific to the HTTP transport (trade-off: the tool becomes unavailable to remote MCP clients). Where HTTP exposure is required, put an authenticating reverse proxy or service mesh in front of the endpoint and block external reachability of the tools/call route (accepting the operational complexity this adds), because pre-1.0.2 builds contain no built-in authentication. Treat the sandbox host as untrusted: run it as a non-root user, avoid host filesystem mounts, and restrict outbound network access to limit post-exploitation filesystem compromise or lateral pivoting. Review deployment for any prior exposure of the endpoint and consider it potentially compromised. Advisory: https://github.com/IBM/mcp-context-forge/security/advisories/GHSA-xm98-3vcf-fph7.

Affected VersionsENISA

mcp-context-forge < 1.0.2

Affected Packages

pypi mcp-contextforge-gateway fix: 1.0.2
euvd mcp_context_forge fix: 1.0.2

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 affected code is mcp-servers/python/python_sandbox_server/src/python_sandbox_server/server_fastmcp.py, a FastMCP-based helper server that runs untrusted Python inside a RestrictedPython sandbox. Three compounding flaws defeat the sandbox: the raw getattr builtin is re-exposed in safe_builtins, so attribute lookups bypass RestrictedPython's _getattr_ mediation; the safe-globals dictionary never installs a _getattr_/_setattr_ guard at all; and validate_code only searched the source text for literal dangerous dunder strings such as __class__, __base__, __subclasses__, __globals__ and __code__. Because the check was substring based, an attacker simply builds the dunder names at runtime by string concatenation, walks the object/class hierarchy through the unguarded getattr, reaches subprocess.Popen and executes commands. This is CWE-94 (improper control of generation of code / code injection) - a classic sandbox-escape via unsanitized attribute access rather than a memory-safety issue. The vendor fix (commit 63a2900e) removes getattr, setattr and hasattr from safe_builtins, injects _getattr_/_setattr_ guards with an allowlist of safe dunders, replaces substring matching with AST-based detection of dangerous attribute nodes, and adds a bearer-token Starlette middleware plus an optional 'http' extra (starlette/uvicorn) for HTTP transport. Severity was assessed at CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, i.e. network-exploitable, unauthenticated, no user interaction and high confidentiality, integrity and availability impact on the sandbox host.

Know when Mcp Context Forge 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 10.0 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 9.8 CRITICAL

Unauthenticated network RCE when HTTP/SSE transport is exposed (PR:N/AV:N/AC:L); S:U because impact is code execution in the sandbox process itself, scope change only conditional so not intrinsic; full C/I/A on the host process.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

DescriptionCVE.org

MCP Context Forge is an AI gateway, registry, and proxy for MCP, A2A, REST, and gRPC APIs. Prior to 1.0.2, the python_sandbox_server in mcp-servers/python/python_sandbox_server/src/python_sandbox_server/server_fastmcp.py exposes raw getattr through safe_builtins, omits a required _getattr_ guard, and relies on validate_code checks for literal dangerous dunder strings. An attacker can construct dunder names at runtime, traverse the Python class hierarchy, reach subprocess.Popen, and execute OS commands with the server process privileges through the execute_code MCP tool. The HTTP/SSE transport can expose this tool without authentication, while stdio-only deployments have reduced network reachability. The issue affects the python_sandbox_server subproject and does not directly affect the core Context Forge gateway or proxy components. This issue is fixed in version 1.0.2.

Technical POC Analysis

Bug class: CWE-94 (code injection) enabled by CWE-693 (protection-mechanism failure) in a RestrictedPython sandbox.

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

IBM MCP Context Forge deployments that expose the optional python_sandbox_server component over HTTP/SSE are exposed to a critical sandbox-escape vulnerability in versions up to and including 1.0.1, allowing arbitrary OS command execution with the server process's privileges. The core gateway and proxy components and stdio-only deployments are not directly affected, so leadership should prioritize identifying and remediating only those environments where the sandbox server is network-reachable. Because publicly available exploit code exists and a vendor patch is available, affected teams should treat this as an urgent containment and patching event to prevent compromise of the sandbox host and any credentials or data it can access.

Business Impact: Severe
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.8%
Top 44% exploitable
Prevalence
Low
emerging AI/MCP gateway project; vulnerable optional python_sandbox_server subproject only
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.8%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Very High

Priority Score

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

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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