Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach unauthenticated HTTP/SSE sandbox endpoint
-
DeliverySubmit execute_code tools/call with obfuscated payload
-
ExploitBypass validate_code via runtime-constructed dunders
-
ExecutionTraverse class hierarchy via raw getattr to subprocess.Popen
-
PersistExecute OS commands as server process
-
ImpactFilesystem 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'). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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 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
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
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.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
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
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.
Apply vendor patch.
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
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.
More in Mcp Context Forge
View allImproper authentication in IBM MCP Context Forge prior to 1.0.2 allows remote, unauthenticated attackers to forge HS256-
Stored cross-site scripting in IBM's MCP Context Forge (versions 0.2.0 up to but not including 0.3.1) lets an authentica
EUVD-2026-78933
GHSA-xm98-3vcf-fph7
NVD
CVE.org
EPSS
VulDB
Exploit-DB