Skip to main content

MLJAR Mercury CVE-2026-111057

| EUVDEUVD-2026-104419 CRITICAL
Incorrect Regular Expression (CWE-185)
2026-10-19 GitHub_M GHSA-f8c7-rwf9-fmgm
10.0
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach Mercury app over network
  2. Delivery
    Request /api/terminals endpoint
  3. Exploit
    Bypass anonymous blocklist via regex flaw
  4. Execution
    Open Jupyter Server terminal shell
  5. Impact
    Execute 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

mercury 3.0.0, < 3.2.4

Affected Packages

pypi mercury fix: 3.2.4

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

Vendor (GitHub_M) PRIMARY 10.0 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 10.0 CRITICAL

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.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Oct 19, 2026 - 17:17 EUVD
CVE Published
Oct 19, 2026 - 16:04 cve.org
CRITICAL 10.0

DescriptionCVE.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.

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

Why It Matters

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.

Business Impact: Severe
Compensating Controls

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

EPSS Score
0.4%
Top 63% exploitable
Prevalence
Low
niche open-source Python/Jupyter dashboard framework, limited enterprise footprint
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Very High

Priority Score

50
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +50
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy