/

CVE-2025-15061

Severity:

CRITICAL RISK

(9.8)

OS Command Injection in Framelink Figma MCP Server

CVE-2025-15061

Awaiting Analysis

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.0

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Framelink Figma MCP Server contains an OS command injection flaw in the fetchWithRetry method that lets attackers inject arbitrary shell commands into system calls.

Because the vulnerable endpoint is exposed without authentication and fails to validate user-controlled input, a remote attacker can achieve code execution in the context of the service account.

Affected context

The vulnerability arises in deployments of the Framelink Figma MCP Server where the fetchWithRetry functionality is reachable over the network and processes data that can be influenced by untrusted clients.

The flaw affects code paths that construct or pass shell commands using user-controllable strings, typically to perform network operations or utility calls.

When input validation and safe command execution primitives are not enforced, the server becomes susceptible to command injection in the service account context.

Exploit preconditions

  • Attack surface: Network-accessible Framelink Figma MCP Server exposing the fetchWithRetry behavior.
  • Required access: No authentication required; an attacker only needs the ability to send crafted requests to the vulnerable interface.
  • Trigger point: Invocation of fetchWithRetry with a user-supplied parameter that is concatenated or interpolated into a system command.
  • Why exploitation is possible: The implementation passes unvalidated, user-controlled strings into a system call (e.g., shell command execution) without proper sanitization, quoting, or use of non-shell execution APIs, enabling arbitrary command injection.

Why this happens

This issue is an instance of CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

The affected fetchWithRetry method appears to build or trigger operating system commands using string concatenation or templating directly from user input, without neutralizing metacharacters such as ;, &&, |, or similar shell constructs.

By treating untrusted input as part of an executable command line, the code blurs the boundary between data and control, allowing attackers to inject additional commands or alter command arguments.

The core pattern is reliance on shell parsing of dynamic strings instead of using parameterized, high-level APIs that separate user data from executable logic.

Potential impact

  • Remote execution of arbitrary OS commands in the context of the Framelink Figma MCP Server service account.
  • Installation of backdoors, web shells, or additional malicious services on the host.
  • Reading, modifying, or exfiltrating configuration files and data accessible to the service account.
  • Lateral movement to adjacent services or systems reachable from the compromised host.
  • Disruption of service availability, including process crashes, resource exhaustion, or deliberate shutdown.
  • Use of the compromised server as a pivot point for broader infrastructure compromise.

General mitigation guidance

Effective mitigation focuses on eliminating data-to-command mixing and reducing the trust level of any data that can reach command execution primitives.

Recommended defensive patterns include:

  • Prefer APIs that do not invoke a shell when executing external programs; use parameterized process execution interfaces that pass arguments as structured arrays rather than raw command strings.
  • Strictly validate and constrain user-controlled fields that might influence system calls; enforce allowlists of permitted values (e.g., fixed commands, restricted flags, or enumerated options).
  • Avoid building command lines with string concatenation or interpolation; if dynamic input is unavoidable, ensure rigorous normalization and neutralization of shell metacharacters.
  • Apply least-privilege principles to the service account so that, even if code execution occurs, the reachable file system, network, and system capabilities are limited.
  • Isolate network-facing components through sandboxing or containerization to contain potential command injection blast radius.
  • Treat all input that crosses trust boundaries (including HTTP bodies, query parameters, headers, and plugin inputs) as untrusted and subject to central validation policies before reaching low-level execution code.

How teams detect issues like this

Identifying and monitoring for OS command injection risks can combine code-centric and runtime approaches:

  • Static analysis: Configure rules to flag use of dangerous process execution APIs (e.g., shell-invoking wrappers) when they receive input derived from HTTP requests or other untrusted sources, especially when string concatenation is present.
  • Code review: During manual review, look for:
  • Functions like fetchWithRetry or similarly named helpers that wrap network requests but also invoke system utilities.
  • Any concatenation or interpolation of user-derived strings into command lines.
  • Lack of allowlists, input normalization, or argument separation when executing external tools.
  • Policy enforcement: Integrate secure coding guidelines into CI pipelines, blocking merges that introduce new shell-based execution paths without justification or input controls.
  • Runtime monitoring: Use logging and intrusion detection to spot anomalous command invocations (unexpected binaries, unusual flags, multi-command sequences) originating from application processes, and correlate them with inbound requests.

Sources

SourceLink
github.comgithub.com/GLips/Figma-Context-MCP/security/advisories/GHSA-gxw4-4fc5-9gr5
zerodayinitiative.comzerodayinitiative.com/advisories/ZDI-25-1197/

Frequently asked

questions

The vulnerability is broadly exploitable because it is reachable over the network without authentication.

Any remote attacker who can send requests to the exposed Framelink Figma MCP Server endpoint can potentially trigger the vulnerable fetchWithRetry path.

No credentials are required according to the description.

The primary requirement is network reachability to the server and knowledge (or discovery) of how to supply the malicious parameter that flows into the system call.

Replace shell-based command execution with higher-level, parameterized process APIs that never invoke a shell, and strictly constrain any user-influenced inputs to a small, validated set of allowable values.

Removing string-built command lines from the code path is more robust than attempting to sanitize all potentially dangerous characters.

Establish a development standard that forbids constructing shell commands from external input, enforce this via code review and automated checks, and centralize safe wrappers for any necessary system interactions.

Combine these practices with least-privilege runtime configurations and continuous security testing (including static analysis and targeted security reviews) for components that handle untrusted data.

Find out what's already
exploitable in your codebase.