/

CVE-2026-75149

Severity:

HIGH RISK

(8.8)

Code Injection (CWE-94) in marimo Notebook Config Handler

CVE-2026-75149

Deferred

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Arbitrary Command Execution

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

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

Summary

A code injection vulnerability in marimo's notebook configuration handler allows attacker-controlled MCP server command values embedded in a notebook to be executed as local subprocesses. The command may run when the notebook is opened in edit mode, before any notebook cell is executed and without requiring authentication.

Affected context

The vulnerability may affect marimo deployments that open notebooks containing crafted MCP server configuration entries and process those entries while entering edit mode. Risk is highest when notebooks originate from untrusted sources or when the marimo process has access to sensitive files, credentials, or other local services.

Exploit preconditions

  • Attack surface: Notebook configuration processing during notebook opening
  • Required access: Ability to provide or cause a victim to open a crafted notebook; authentication is not generally required
  • Trigger point: Opening the notebook in edit mode
  • Why exploitation is possible: An attacker-controlled command value is passed to local subprocess execution before notebook cell execution or equivalent safety validation

Why this happens

The underlying flaw is the failure to treat command values in notebook configuration as untrusted data. A configuration handler accepts an attacker-controlled MCP server entry and uses its command field to launch a local process without sufficiently restricting or validating executable content. This behavior maps to CWE-94: Improper Control of Generation of Code ('Code Injection'), because data supplied through a notebook can influence executable behavior.

Potential impact

  • An attacker may execute arbitrary commands with the privileges of the marimo process.
  • The vulnerability could expose local files, environment variables, or service credentials.
  • A compromised process may alter notebooks, project files, or other accessible data.
  • The issue can enable follow-on compromise of connected services or development environments.

General mitigation guidance

Mitigation generally focuses on removing implicit command execution from notebook configuration handling and reducing trust in notebook-supplied values.

Common defensive patterns include:

  • Treating MCP server command fields as data unless explicit, user-reviewed execution is required.
  • Allowing only narrowly defined executable identifiers and arguments through an application-controlled policy.
  • Requiring clear user confirmation before launching locally sourced commands.
  • Separating notebook parsing from process creation and applying validation before any subprocess is started.
  • Running marimo with least privilege, restricted filesystem access, and minimal environment credentials.
  • Prefering managed integrations or declarative configurations that do not permit arbitrary command strings.

How teams detect issues like this

Organizations can look for this vulnerability class through:

  • Static analysis for configuration values flowing into subprocess, shell, or process-spawning APIs.
  • Code review checks for notebook or project metadata that directly controls executable paths or arguments.
  • Tests that open untrusted notebooks and verify that parsing does not launch processes without an explicit approval boundary.
  • Policy enforcement that restricts command-bearing configuration fields and blocks shell interpretation where it is unnecessary.
  • Runtime monitoring for unexpected child processes launched by notebook servers or development tools.

Neutral automated code review and software composition tools may help identify command-injection data flows early.

Sources

SourceLink
github.comgithub.com/marimo-team/marimo/commit/1a21bd71e258438d2511136b5edacc94c08855f4
github.comgithub.com/marimo-team/marimo/pull/10281
github.comgithub.com/marimo-team/marimo/releases/tag/0.23.15
vulncheck.comvulncheck.com/advisories/marimo-code-injection-via-mcp-server-configuration

Frequently asked

questions

It can be triggered through a crafted notebook supplied from an untrusted source, but execution occurs on the local system when the notebook is opened in edit mode. Exploitability therefore depends on whether a user or automated workflow opens the notebook.

No authentication or notebook cell execution is required according to the vulnerability description. Opening the notebook in edit mode is the relevant trigger.

Do not allow notebook-controlled values to directly launch local commands. Use explicit approval, strict allowlists, validated argument handling, and non-executable declarative configuration where possible.

Treat notebooks and embedded metadata as untrusted input, review all data flows into process-spawning APIs, enforce least privilege, and add tests and policy checks that detect implicit command execution.

Find out what's already
exploitable in your codebase.