Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach Mercury app over network
-
DeliveryRequest /api/terminals endpoint
-
ExploitBypass anonymous blocklist via regex flaw
-
ExecutionOpen Jupyter Server terminal shell
-
ImpactExecute OS commands as Mercury process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Incorrect input validation
|
| Exploitation Conditions | Requires a Mercury deployment (3.0.0 through 3.2.3) that serves content to anonymous/unauthenticated users, since the flaw lies in the anonymous endpoint blocklist that is supposed to shield Jupyter Server from unauthenticated callers. The specific trigger is any HTTP request to the /api/terminals path (e.g. /api/terminals or /api/terminals/1), which the malformed regex fails to match and therefore passes through to Jupyter Server's terminal API. Exploitation also depends on Jupyter Server's terminal feature being enabled/available behind Mercury (the default) so that a shell can actually be opened. Limiting factors: the instance must be network-reachable and running an affected version; upgrading to 3.2.4 fully closes the path. No authentication, user interaction, or non-default configuration beyond ordinary anonymous sharing is required. |
| Impact | All severity signals point the same direction here, making this a genuine top-priority issue rather than CVSS inflation. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H = 10.0) is fully supported by the description: a remote, unauthenticated attacker reaches Jupyter Server's terminal API through Mercury's broken anonymous blocklist and obtains an interactive OS shell, yielding full confidentiality, integrity, and availability impact with a scope change (the Mercury blocklist component's failure exposes a distinct Jupyter Server security authority). The root cause is confirmed by source evidence - a missing comma in BLOCKED_PATTERNS concatenating the /lab and /api/terminals regex literals (CWE-185, incorrect regex) - so the technical impact is not speculative. However, several exploitation signals are MISSING, not negative: no EPSS score is provided, the CVE is not listed in CISA KEV, and no public exploit (PoC) was supplied - the GitHub source material is the fix commit, not weaponized exploit code. Therefore active exploitation cannot be claimed. The practical risk is tempered by prevalence: Mercury (mljar) is a niche open-source framework, so the absolute number of exposed instances is likely small, but any internet-exposed instance running anonymous mode on 3.0.0-3.2.3 should be treated as critical and patched immediately. |
| Exploit ScenarioDerived | An attacker locates an internet-reachable Mercury dashboard (versions 3.0.0-3.2.3) that serves notebooks to anonymous users and sends an HTTP request to /api/terminals, which the broken blocklist fails to block. The request reaches Jupyter Server's terminal API, giving the attacker an interactive operating-system shell to run commands and read data as the Mercury process. No public exploit code was provided in the input, but the trivial single-character root cause makes reproduction straightforward once the fix diff is public. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Unauthenticated remote command execution is possible in MLJAR Mercury 3.0.0 through 3.2.3 because a missing comma in the BLOCKED_PATTERNS list merges the /lab and /api/terminals regular expressions into a single pattern, so requests to /api/terminals no longer match the anonymous-endpoint blocklist and are proxied straight to Jupyter Server's terminal API. An attacker with network access to a Mercury instance that serves dashboards to anonymous users can therefore open an interactive operating-system shell and run commands with the privileges of the Mercury process (CVSS 10.0, AV:N/AC:L/PR:N/UI:N/S:C). All severity signals agree - network reachability with no credentials or user interaction, scope change into the underlying Jupyter Server, and high confidentiality/integrity/availability impact - and the only limiting factor is that the instance must be reachable and running an affected version; no public exploit code or confirmed active exploitation was identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade MLJAR Mercury to 3.2.4, which restores the missing comma in mercury_app/block_handler.py and adds regression tests covering /api/terminals (release: https://github.com/mljar/mercury/releases/tag/v3.2.4, commit: https://github.com/mljar/mercury/commit/8c467129037ee9df269d543ac217ffd33b97bf3f, advisory: https://github.com/mljar/mercury/security/advisories/GHSA-f8c7-rwf9-fmgm). If upgrading cannot be done immediately, the most effective compensating control is to disable Jupyter Server's terminal feature in the server config behind Mercury (c.ServerApp.terminals_enabled = False, or the equivalent --ServerApp.terminals_enabled=False flag), which removes the shell primitive entirely - the trade-off is that legitimate terminal use by notebook authors stops working; as a second layer, block /api/terminals and /api/terminals/* at the reverse proxy or ingress in front of Mercury (nginx location ~ ^/api/terminals { deny all; }), noting that this must be replicated on every ingress path and websocket route or it can be bypassed; additionally, requiring authentication for all Mercury/Jupyter access removes the anonymous-attacker precondition but changes the sharing model of public dashboards. Because exploitation yields command execution as the Mercury process, rotate any secrets or tokens reachable from that process environment after confirming or suspecting compromise.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Mercury is a Python framework that publishes Jupyter notebooks as web apps, sitting in front of a Jupyter Server that it shields from anonymous visitors via a list of blocked URL regexes in mercury_app/block_handler.py. The bug is a textbook CWE-185 (Incorrect Regular Expression): the r"/lab(?!/(?:extensions/|api/settings(?:/|$)|api/translations(?:/|$)))(?:/.*)?" literal was missing its trailing comma, so Python implicitly concatenated it with the adjacent /api/terminals pattern into one long regex string instead of keeping them as two list entries. Because the merged pattern only ever fullmatches /lab-prefixed paths, /api/terminals and /api/terminals/<id> fell through the blocklist and were handed to Jupyter Server's terminal API. Jupyter Server's terminal handler is a websocket-backed PTY endpoint, so any successfully created terminal yields an interactive shell in the container/host namespace of the Mercury process - hence the scope change (S:C) and full C/I/A impact in the assessed vector. The upstream fix (commit 8c467129037ee9df269d543ac217ffd33b97bf3f, released as v3.2.4) restores the missing comma and adds mercury/tests/test_block_handler.py, which asserts that /api/terminals and /api/terminals/1 are blocked while the intentionally allowed /lab/api/settings and /lab/api/translations routes still pass.
Know when Mercury 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
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
Remote unauthenticated request with no interaction (AV:N/AC:L/PR:N/UI:N); blocklist failure exposes a separate Jupyter Server authority (S:C); OS shell yields full C:H/I:H/A:H.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Mercury is a Python framework for sharing Jupyter notebooks as web applications and dashboards. From 3.0.0 until 3.2.4, a missing comma in BLOCKED_PATTERNS concatenates the /lab and /api/terminals regular-expression literals. Requests to /api/terminals therefore bypass the anonymous endpoint blocklist and reach Jupyter Server's terminal API. An unauthenticated attacker can use the resulting interactive operating-system shell to execute commands and access data available to the Mercury process. This issue is fixed in version 3.2.4.
Articles & Coverage 1
Technical POC Analysis
The defect is in mercuryapp/blockhandler.py in the BLOCKEDPATTERNS list.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
MLJAR Mercury versions 3.0.0 through 3.2.3 contain a critical, unauthenticated remote command execution flaw that lets anyone with network access to an anonymously served dashboard obtain an interactive operating-system shell running as the Mercury process. Because exploitation needs no credentials and no user interaction, any externally reachable Mercury deployment exposing dashboards to anonymous users effectively hands attackers a foothold on the host, with potential to pivot into the underlying Jupyter Server and any data or systems it can reach. Leadership should treat every affected instance as internet-exposed until network access is restricted, since no vendor patch is currently available.
No vendor-released patch identified at time of analysis. Interim mitigations: disable anonymous dashboard access and require authentication; restrict network reachability of Mercury instances via VPN, allowlists, or segmentation; block or filter requests to /api/terminals at the reverse proxy, WAF, or ingress layer; run the Mercury process under a least-privilege, isolated service account with no access to sensitive credentials or internal systems; monitor and alert on terminal API access and anomalous process execution.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
Unauthenticated remote code execution in MLJAR Mercury deployments running the default tokenless configuration allows an
An XXE issue exists in Accenture Mercury before 1.12.28 because of the platformlambda/core/serializers/SimpleXmlParser.j
Stored/DOM cross-site scripting in Mercury's mr.Markdown widget (versions 3.0.0 through 3.2.10) allows attacker-supplied
EUVD-2026-104419
GHSA-f8c7-rwf9-fmgm
NVD
CVE.org
EPSS
VulDB
Exploit-DB