External risk intelligence

Mercury Anonymous Kernel Creation and Code Execution Vulnerability.

CVE advisorySeverity: CRITICAL (CVSS 9.8)

CVE-2026-111058

Mercury is a framework specifically designed to share Jupyter notebooks as web applications and dashboards. Because the primary purpose of the product is to host and expose interactive content or web apps to users, these deployments are commonly internet-facing or reachable via an external-facing web server to facilitate that sharing.

Halo Surface Signal: 4 out of 5 — likely to be public-facing.

External exposure likelihood

Horizon Alert

Summary of the vulnerability and why it matters

A vulnerability exists in the Mercury framework that allows unauthenticated users to execute arbitrary Python code by creating Jupyter kernels. This could potentially lead to significant compromise of systems running affected versions of Mercury, which is used for sharing Jupyter notebooks as web applications. The main concern is confirming whether your organization uses this technology and is exposed.

  • Unauthenticated code execution via web applications.
  • Affects systems sharing interactive notebooks.
  • Confirm relevance and exposure.

Attack Path

How an attacker could exploit the issue

An attacker could exploit this vulnerability by accessing a Mercury deployment that uses default tokenless configurations. Since the framework is designed for sharing notebooks as web applications, these deployments are often exposed externally. An attacker could then create a Jupyter kernel and send messages that execute arbitrary Python code, potentially leading to unauthorized actions and data compromise.

  • No authentication required.
  • Create kernel and send executable messages.
  • Arbitrary code execution and data compromise.

Live Threat

Current exploitation, exposure, and threat context

When deployed with default tokenless configurations, this vulnerability could allow unauthenticated users to create and interact with Jupyter kernels, potentially executing arbitrary Python code. This could affect the behavior of the Mercury service and any underlying system resources it accesses.

  • System data and service behavior.
  • Anonymous clients can execute arbitrary Python.
  • Compromise of service and underlying systems.

Operational Fix

Recommended remediation, mitigation, and detection steps

This vulnerability in Mercury impacts deployments that allow anonymous, tokenless access, enabling unauthenticated users to execute arbitrary Python code. Platform or infrastructure teams are likely responsible for managing the Mercury framework, while application owners who use Mercury to share notebooks must be engaged. The first practical step is to identify all Mercury instances, determine their exposure and criticality, and then coordinate remediation with the appropriate teams.

  • Identify Mercury deployments and ownership.
  • Verify anonymous access and reachability.
  • Plan remediation based on risk.

Supplementary metadata

Validate whether this threat affects your internet-facing exposure.

Halo Threat Intelligence helps prioritize remediation with Halo Surface Signal and H/A/L/O context. Start exposure validation with a free external attack surface trial.

Frequently asked questions

What is the Mercury framework used for?

Mercury is a specialized Python framework designed to transform Jupyter notebooks into interactive web applications and dashboards. Users rely on it to share data analysis, models, and visualizations with others through a web interface, making it a bridge between technical notebook environments and standard browser-based access.

How does CVE-2026-111058 enable unauthorized code execution?

This vulnerability involves a missing authorization weakness (CWE-862). In affected versions, the Mercury framework fails to properly restrict access to kernel-related API endpoints. This allows an unauthenticated user to create a Jupyter kernel and send messages that the server processes as executable Python code, bypassing the security controls intended to protect the system.

When does this vulnerability pose a risk to my Mercury installation?

The risk occurs primarily when Mercury is running in a default, tokenless configuration that permits anonymous access. If your deployment requires valid authentication tokens for all users, the trigger path is significantly restricted. The vulnerability specifically exploits endpoints that were not properly blocklisted, allowing unauthorized interaction with the underlying execution environment.

Is my Mercury deployment likely to be reachable by external attackers?

According to Halo Surface Signal, Mercury is inherently designed to host interactive content for broad user access, which frequently results in these applications being internet-facing. Because these services are intended to be shared, they are often reachable via external networks, increasing the likelihood that an attacker could identify and interact with an vulnerable instance.

What is the first step to address this Mercury vulnerability?

Begin by auditing your environment to locate all active Mercury instances and determine who manages them. Once identified, verify whether your specific deployments utilize tokenless configurations that allow anonymous access. Coordinate with your application owners to prioritize patching these instances to version 3.2.6, which resolves the authorization gaps in the API and websocket handling.

References