Skip to main content

FrontMCP CVE-2026-67531

CRITICAL
Code Injection (CWE-94)
2026-08-05 GitHub_M
9.3
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach FrontMCP MCP endpoint (default public)
  2. Delivery
    Send tools/call to codecall:execute
  3. Exploit
    Script calls getTool() to obtain live Zod schema
  4. Execution
    Traverse _zod.constr.constructor to host Function
  5. Persist
    Execute arbitrary code as server user
  6. Impact
    Exfiltrate JWT_SECRET, DB creds, cloud metadata

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

The server must be running FrontMCP prior to 1.5.7 with the CodeCall plugin's codecall:execute tool enabled and reachable, and with tool schemas defined using Zod v4 (whose non-configurable, non-writable _zod own property forces the Proxy membrane to leak the raw host object). No special conditions are required against default configurations: the framework's DEFAULT_AUTH_OPTIONS is public mode, so an unconfigured server serves codecall:execute to remote unauthenticated callers, and one tools/call suffices to escape. Limiting factors: on servers explicitly configured with authentication, direct exploitation requires a valid caller, though an indirect prompt-injection payload in fetched content or upstream tool output can still trigger it without a human attacker; the codecall:execute tool must be exposed (removing/disabling CodeCall eliminates the vector), and the target tool must be within any allowedTools whitelist the script was invoked with.

Impact

The vendor CVSS 4.0 vector (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H, score 9.3) is internally consistent with the description: network-reachable, low complexity, no privileges or user interaction required against a default public-mode server, with high confidentiality, integrity, and availability impact from arbitrary code execution. This is a genuine top-tier priority, not a high-CVSS-but-low-real-risk case: exploitation needs a single tools/call, requires no special preconditions on default configurations, and yields full server compromise plus secret exfiltration. Note the vector marks subsequent-system impact SC/SI/SA:N even though this is technically a sandbox escape into the host process - arguably a scope-change condition - so real blast radius (host, then any downstream systems reachable with the stolen credentials) may exceed what the base metrics convey. No EPSS score or CISA KEV entry is provided, so widespread automated exploitation is not confirmed; however, the escape technique is fully documented in the GHSA advisory and reproduced in the fix commit's regression tests, materially lowering the barrier to weaponization. On authenticated deployments the PR:N assumption is weaker, but the description notes indirect prompt injection in tool output or fetched content can trigger the same path without a human attacker.

Exploit ScenarioDerived

An attacker sends a single tools/call to a network-reachable FrontMCP server invoking codecall:execute with a short script that calls getTool() on any tool, reads the returned schema's _zod internal, and walks _zod.constr.constructor to obtain the host Function constructor, then runs Function('return process')() to execute arbitrary code and read environment secrets. On a default public-mode server this needs no authentication; on an authenticated server, an attacker can instead plant an indirect prompt injection in content the agent fetches or in another tool's output so the agent itself issues the malicious script. Publicly available exploit code exists - the fix commit's regression tests demonstrate the exact escape sequence.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
No patch listed yet 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 05, 2026

Sandbox escape leading to remote code execution in FrontMCP (agentfront/frontmcp) before 1.5.7 lets a single tools/call to the codecall:execute tool break out of the script sandbox and run arbitrary code as the server user. The security membrane hands back live host Zod v4 schema instances via getTool(), giving script authors a path to the host Function constructor and full process control, exposing OAuth client secrets, JWT_SECRET, session keys, database credentials, and cloud metadata. Because the framework ships DEFAULT_AUTH_OPTIONS in public mode, unconfigured servers expose this to unauthenticated callers, and publicly available exploit code exists in the form of the fix commit's regression tests demonstrating the exact escape technique.

RemediationAI

Vendor-released patch: 1.5.7 - upgrade FrontMCP to 1.5.7 or later, which returns tool schemas from getTool() as inert plain JSON Schema documents (null when no schema is declared) so no live host Zod instance is reachable; this is the primary and complete fix. Until you can upgrade, do not run unconfigured servers in default public mode: enable authentication so the codecall:execute path is not exposed to unauthenticated callers, and treat that as reducing-not eliminating-risk, since indirect prompt injection in tool output or fetched content can still reach the sandbox on authenticated servers. As additional compensating controls, disable or remove the CodeCall plugin / codecall:execute tool entirely if scripting is not required (trade-off: loses all script-execution functionality), restrict tool exposure via the allowedTools whitelist so scripts cannot describe sensitive host tools, and sanitize or distrust externally fetched content and upstream tool output that feeds into scripts to blunt prompt-injection triggers. Rotate any secrets the process holds (OAuth client secrets, JWT_SECRET, session keys, database credentials) if you cannot rule out prior exploitation. References: GHSA-mp29-fxh8-92px (https://github.com/agentfront/frontmcp/security/advisories/GHSA-mp29-fxh8-92px) and commit 209cddd19a8d4db0777f725b527818da7df6f67f.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

FrontMCP is a TypeScript-first framework implementing the Model Context Protocol (MCP), the emerging standard by which LLM agents call server-side tools. Its CodeCall plugin runs agent-authored scripts inside a sandbox guarded by an ECMAScript Proxy 'membrane' that is supposed to return only inert copies of host objects. The root cause maps to CWE-94 (Improper Control of Generation of Code / code injection): the getTool() helper returns tool metadata whose schemas are backed by live Zod v4 validator instances. Zod v4 defines its internal _zod field as a non-configurable, non-writable own property, and the ECMAScript Proxy invariants require that a non-configurable, non-writable property report the exact underlying value - so the membrane is forced to hand back the raw host object rather than a proxy or copy. From that raw object a script traverses _zod.constr.constructor to reach the host Function constructor and evaluate strings like Function('return process')(), gaining full Node.js host capabilities. The fix (1.5.7) returns tool schemas as plain, inert JSON Schema documents that carry no schema-instance internals or methods. Affected CPE: cpe:2.3:a:agentfront:frontmcp.

Know when Frontmcp 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 9.3 CRITICAL
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 9.8 CRITICAL

Default public mode makes it network-reachable and unauthenticated (AV:N/PR:N), a single scriptable call is low-complexity (AC:L/UI:N), and host RCE yields full C:H/I:H/A:H.

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
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

FrontMCP is a TypeScript-first framework for the Model Context Protocol (MCP). Prior to 1.5.7, the sandboxed codecall:execute tool exposes live host Zod schema instances to the script via getTool(), and because Zod v4 defines _zod as a non-configurable, non-writable own property, the ECMAScript Proxy invariants force the security membrane to hand back the raw host object, letting a script reach _zod.constr.constructor (the host Function constructor) and execute arbitrary code in the server process. A single tools/call is sufficient to escape the sandbox and achieve remote code execution as the server user, exposing everything the process holds such as OAuth client secrets, JWT_SECRET, session keys, database credentials, and cloud instance metadata. Because the framework's DEFAULT_AUTH_OPTIONS is public mode, an unconfigured server serves this to unauthenticated callers, and on authenticated servers an indirect prompt injection in tool output or fetched content can trigger it without a human attackerThis issue is fixed in version 1.5.7.

Executive ViewAI

Why It Matters

FrontMCP, an agent framework, contains a critical remote code execution vulnerability (CVSS 9.3) that allows unauthenticated attackers to escape the sandbox and execute arbitrary code on affected servers. Organizations running unconfigured or default deployments are at immediate risk of total compromise, with attackers gaining access to OAuth credentials, API keys, database credentials, and cloud metadata. This requires urgent remediation across all FrontMCP instances.

Business Impact: Severe
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) immediately restrict FrontMCP access to internal networks only and disable all public-facing exposure; (2) implement strict firewall rules limiting connections to authorized users and systems; (3) disable public mode and DEFAULT_AUTH_OPTIONS, requiring explicit authentication on all instances; (4) identify and rotate any OAuth credentials, API keys, database passwords, and cloud access tokens that may have been exposed; (5) enable audit logging and monitor for unauthorized codecall:execute invocations and suspicious activities.

Threat Intelligence Overview

EPSS Score
0.4%
Top 64% exploitable
Prevalence
Low
niche emerging TypeScript MCP framework, limited production footprint
Social Media
4
Sightings
Data Quality
6 sources
Confidence: High
NVD CVE.org EPSS Vulnrichment CIRCL GitHub VulDB

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.4%
Patch available No
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
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Total

Priority Score

46
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +46
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.

Affected Products (CPE)CVE.org

cpe:2.3:a:agentfront:frontmcp:*:*:*:*:*:*:*:*

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