Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft notebook with malicious PEP-723 base_url
-
DeliveryDistribute notebook to target operator via plausible channel
-
ExploitOperator opens notebook in marimo (base_url injected into session config at parse time)
-
ExecutionOperator triggers AI feature (code completion or chat)
-
Persistmarimo resolves attacker base_url with operator OPENAI_API_KEY as Bearer token
-
ImpactAPI key silently transmitted to attacker-controlled endpoint
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V15 - Secure Coding and Architecture Data authenticity verification
|
| Exploitation Conditions | Three specific conditions must align for exploitation: first, the victim must be running marimo before 0.23.15 with an AI provider API key (such as OPENAI_API_KEY) set as an environment variable in the marimo process; second, the operator must open a notebook containing an attacker-controlled |
| Impact | The provided CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N, score 7.1) accurately captures the threat model: the attack is network-reachable, low-complexity, requires no attacker privileges, and demands exactly one user interaction - the operator must open the notebook and invoke an AI feature. The high confidentiality impact reflects that the exfiltrated credential (OPENAI_API_KEY) is a high-value secret with direct financial and access consequences. No EPSS score is present in the provided data; risk cannot be quantified probabilistically from available sources. No CISA KEV listing is present, and no confirmed public POC exists, but VulnCheck (the reporter) published a full technical advisory, which is a meaningful intelligence signal - the mechanism is now documented and reproducible by moderately skilled researchers. Real-world risk is concentrated among organizations where: (1) operators use marimo's built-in AI features, and (2) operators may open notebooks from semi-trusted or unknown sources (e.g., GitHub, shared workspaces, data science communities). The attack is supply-chain in character - a convincing notebook shared through legitimate channels could reach many targets before detection. Risk is bounded by the requirement that the operator actively triggers an AI request while the malicious notebook is open; passive opening alone does not exfiltrate the key. |
| Exploit ScenarioDerived | An attacker crafts a marimo notebook - plausibly a data analysis or AI demonstration script - and injects a malicious |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 04, 2026
Configuration injection in marimo before 0.23.15 enables a malicious notebook author to silently exfiltrate an operator's OpenAI API key by embedding an attacker-controlled base_url in PEP-723 inline script metadata, which the sanitize_pyproject_dict function merges into session configuration at higher precedence than the operator's own settings. When the operator opens the crafted notebook and invokes any AI feature - code completion, AI chat, or similar - marimo resolves the injected endpoint while supplying the operator's OPENAI_API_KEY as the Authorization credential, transmitting it to the attacker's server. Critically, no cell execution is required; the exfiltration fires on the AI request itself. No public exploit confirmed at time of analysis, though VulnCheck's detailed advisory materially lowers the reproduction barrier. Patch is available in marimo 0.23.15.
RemediationAI
Upgrade marimo to version 0.23.15 or later immediately; this is the vendor-released patch confirmed by the GitHub release at https://github.com/marimo-team/marimo/releases/tag/0.23.15 and the specific fix at commit 1a21bd71e258438d2511136b5edacc94c08855f4 (PR #10281). For operators who cannot patch immediately, disable marimo's AI features at the deployment level to prevent any scenario in which the OPENAI_API_KEY or equivalent credential is transmitted to an external endpoint - note that this disables AI-assisted code completion and AI chat functionality as a trade-off. Until patched, restrict notebook sources to a vetted, trusted set and do not open notebooks from unknown or community sources in any environment where API keys are configured. As a precautionary measure, rotate any OPENAI_API_KEY that may have been active in a marimo environment that processed untrusted notebooks, since the exfiltration leaves no error trace for the operator. Full advisory context from VulnCheck is available at https://www.vulncheck.com/advisories/marimo-api-key-exfiltration-via-malicious-notebook-pep-723-metadata.
Affected VersionsENISA
Affected Packages
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 is a reactive Python notebook framework (CPE: cpe:2.3:a:marimo-team:marimo:*:*:*:*:*:*:*:*) that supports PEP-723 inline script metadata, a standard mechanism for embedding dependency and configuration data directly in Python script files. marimo extends this to allow AI endpoint configuration - including base_url - to be specified per-notebook. The vulnerable function sanitize_pyproject_dict is responsible for ingesting and sanitizing these notebook-level settings before merging them into the active session configuration. Due to CWE-345 (Insufficient Verification of Data Authenticity), the function fails to reject or sanitize attacker-supplied base_url values, and the merge order gives notebook-supplied keys higher precedence than operator-level defaults. This means a crafted notebook can silently override the AI provider endpoint without operator awareness. The flaw sits at the notebook parsing and session configuration boundary - a trust boundary between untrusted notebook content and privileged operator runtime context - making it exploitable at notebook-load time rather than requiring cell execution.
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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
Network-distributed notebook requires operator to trigger AI request (UI:R); no attacker privileges needed on target; impact is confidentiality-only via API key theft with no integrity or availability consequence.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
marimo before 0.23.15 contains a configuration injection vulnerability that allows notebook authors to exfiltrate operator API keys by embedding a malicious base_url in PEP-723 inline script metadata, which is merged into session configuration with higher precedence than the operator's own settings due to insufficient sanitization in sanitize_pyproject_dict. When an operator opens the crafted notebook and makes an AI request, marimo resolves the attacker-controlled base_url from the notebook config while falling back to the operator's OPENAI_API_KEY environment variable for authentication, transmitting the API key to the attacker-controlled endpoint without requiring any cell execution.
Executive ViewAI
marimo before version 0.23.15 enables silent exfiltration of users' OpenAI API keys through malicious notebooks, directly exposing organizations to unauthorized API consumption and potential data breach costs. Any organization using marimo with OpenAI integrations must patch immediately to version 0.23.15 to prevent credential compromise.
Apply vendor patch: marimo 0.23.15
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.
Code injection in marimo before 0.23.15 allows an attacker who can deliver a crafted notebook file to execute arbitrary
Reflected XSS in the marimo notebook server before version 0.23.9 enables unauthenticated remote attackers to inject and
EUVD-2026-52702
GHSA-v9v8-jp27-55gf
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB