Skip to main content

marimo CVE-2026-75149

| EUVDEUVD-2026-62665 HIGH
Code Injection (CWE-94)
2026-08-19 VulnCheck GHSA-gfgh-xp6v-q37q
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft notebook with malicious MCP server command
  2. Delivery
    Deliver notebook to target user
  3. Exploit
    Victim opens notebook in marimo edit mode
  4. Execution
    marimo configuration handler parses MCP entry
  5. Persist
    Malicious command launched as local subprocess
  6. Impact
    Arbitrary code executes as victim's OS user

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 victim must open an attacker-controlled or attacker-modified marimo notebook file in marimo's edit mode (as opposed to run mode or a read-only viewer). The notebook must contain a crafted MCP server configuration entry with a malicious command value. No authentication to any service is required from the attacker's side; the CVSS 4.0 vector confirms PR:N (no privileges). The vulnerability does not require any notebook cell to be executed - the subprocess is launched during notebook initialization. Exploitation is limited by the requirement for passive user interaction (UI:P): the victim must actively open the file in edit mode. Non-default configurations or special feature flags are not required beyond the MCP server entry being present in the notebook configuration block. The attack is local in execution impact (subprocess runs as the user running marimo) with no confirmed scope change to other systems (SC:N/SI:N/SA:N in the CVSS 4.0 vector).

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N) scores 8.7, reflecting near-automatic exploitation once a victim opens the file. The sole friction is UI:P (passive user interaction - opening a notebook), which meaningfully limits mass-exploitation scenarios but is a routine action for marimo's target audience of data scientists and developers. No CISA KEV listing is present and no POC code is referenced in the available intelligence, suggesting exploitation has not been observed at scale. The attack complexity is genuinely low: no authentication, no special configuration, and no exploit chain beyond file delivery. Real-world risk is highly dependent on notebook sharing workflows - organizations where users regularly open notebooks from external or untrusted sources (e.g., public GitHub repositories, email attachments, shared collaboration links) face elevated exposure. EPSS data was not provided; given the niche deployment footprint, broad automated scanning is unlikely.

Exploit ScenarioDerived

An attacker publishes or sends a marimo notebook file (.py or .ipynb) that embeds a malicious MCP server configuration entry with an attacker-controlled command (e.g., a reverse shell or data exfiltration script). When a data scientist or developer opens the file in marimo's edit mode - a routine action - marimo's configuration handler reads the MCP entry and launches the embedded command as a local subprocess before displaying the notebook interface, granting the attacker immediate code execution on the victim's workstation. No public proof-of-concept code has been identified, but the attack is mechanically straightforward given the vulnerability description.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.6% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 19, 2026

Code injection in marimo before 0.23.15 allows an attacker who can deliver a crafted notebook file to execute arbitrary operating system commands on the victim's machine simply by having the victim open the notebook in edit mode. The vulnerability resides in the notebook configuration handler's MCP (Model Context Protocol) server entry processing: marimo reads attacker-controlled command values from the notebook's configuration and spawns them as local subprocesses before any notebook cell runs, giving the attacker immediate code execution with no further interaction required. No public exploit or CISA KEV listing has been identified at time of analysis, but the CVSS 4.0 score of 8.7 and PR:N vector reflect the low barrier to exploitation once a victim opens a malicious file.

RemediationAI

Upgrade marimo to version 0.23.15 or later, which contains the fix introduced in PR #10281 (https://github.com/marimo-team/marimo/pull/10281) and committed at https://github.com/marimo-team/marimo/commit/1a21bd71e258438d2511136b5edacc94c08855f4. The fix is confirmed by the vendor release at https://github.com/marimo-team/marimo/releases/tag/0.23.15. If an immediate upgrade is not possible, the most effective compensating control is to avoid opening notebooks from untrusted sources in edit mode; notebooks from unknown or external parties should be reviewed as raw files (e.g., text editor or read-only mode) before being opened in marimo's interactive environment. Additionally, running marimo in a sandboxed environment (container with restricted subprocess capabilities, or a user account with minimal OS privileges) would limit the blast radius of exploitation but would not prevent the command from being invoked.

Affected VersionsENISA

marimo 0 <0.23.15

Affected Packages

euvd marimo fix: 0.23.15

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

marimo (CPE: cpe:2.3:a:marimo-team:marimo:*:*:*:*:*:*:*:*) is a Python-based reactive notebook environment that supports MCP (Model Context Protocol) server integration. Notebook files can embed MCP server configuration entries that specify external commands for marimo to launch. The affected code path in the notebook configuration handler - present in all versions before 0.23.15 - passes the command value from this configuration directly to a subprocess invocation without sanitization or allowlisting, constituting a CWE-94 (Improper Control of Generation of Code / Code Injection) flaw. Because subprocess launch occurs during notebook initialization in edit mode, prior to any cell execution, the malicious command runs as part of the application's own startup sequence under the privileges of the user running marimo.

Know when Marimo 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 (VulnCheck) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 8.8 HIGH

Attacker requires no privileges or auth; victim must open the notebook (UI:R); full C/I/A impact on local system with no scope change.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
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

marimo before 0.23.15 contains a code injection vulnerability in the notebook configuration handler that allows attackers to execute arbitrary commands by supplying a crafted MCP server entry with an attacker-controlled command value embedded in a notebook. When the notebook is opened in edit mode, marimo launches the specified command as a local subprocess before any notebook cell is executed, requiring no authentication or cell execution to trigger the vulnerability.

Executive ViewAI

Why It Matters

marimo, a widely-used notebook platform, contains a code execution flaw that exposes any organization using it to system-level compromise when users open malicious notebook files. The attack requires no authentication or prior system access and can execute arbitrary commands, enabling attackers to establish persistent access to development and data science environments. Immediate patching is critical to prevent breach of sensitive analytical assets and code repositories.

Business Impact: Severe
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.6%
Top 52% exploitable
Prevalence
Low
emerging Python notebook tool, smaller footprint than Jupyter
Data Quality
7 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 HIGH
CISA KEV No
Public POC No
EPSS 0.6%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
Very High
Technical Impact
Total

Priority Score

45
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +44
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