/

CVE-2026-23523

Severity:

CRITICAL RISK

(9.6)

Code Injection in Dive MCP Host Desktop Application

CVE-2026-23523

Analyzed

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Arbitrary Local Command Execution

Severity:

CRITICAL RISK

(9.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A code injection vulnerability in the Dive MCP Host Desktop Application allows a crafted deeplink to silently install an attacker-controlled MCP server configuration with insufficient user confirmation.

When a victim opens a malicious deeplink, the application may end up executing arbitrary local commands via the configured MCP server, leading to full compromise of the user's machine context.

Affected context

This issue affects deployments of the Dive MCP Host Desktop Application that process deeplinks to add or configure MCP servers.

The vulnerability manifests when the application:

  • Accepts deeplinks from external sources (e.g., browser, other apps)
  • Automatically or semi-automatically imports MCP server configurations from those deeplinks
  • Treats the imported configuration as trusted and capable of running local commands

In such setups, user interaction and confirmation around installing or activating new MCP configurations may be minimal or ambiguous.

Exploit preconditions

  • Attack surface: Deeplink handling in the Dive desktop application (e.g., dive://-style or equivalent custom protocol links).
  • Required access: Ability to convince or trick a user into opening a crafted deeplink (e.g., via email, chat, web page, or document).
  • Trigger point: The moment the Dive application processes the deeplink and imports or activates the supplied MCP server configuration.
  • Why exploitation is possible: The deeplink-driven configuration flow does not adequately validate or constrain the imported MCP server definition, and does not require sufficiently explicit user consent before enabling a configuration that can initiate arbitrary local command execution.

Why this happens

The root cause is insufficient separation between configuration import and command-capable execution, combined with overly trusting deeplink input.

The application allows deeplinks to define or modify MCP server configurations that can execute local commands, but does not enforce strict validation, sandboxing, or explicit user approval for potentially dangerous actions.

This aligns with CWE-94: Improper Control of Generation of Code ('Code Injection'), as externally supplied configuration effectively enables attacker-controlled logic to be invoked on the local system without proper constraints.

Potential impact

  • Execution of arbitrary commands on the victim's machine under the privileges of the Dive application user.
  • Installation of persistent backdoors or malware via command execution.
  • Exfiltration of local files and sensitive data accessible to the user account.
  • Lateral movement within the user's environment (e.g., accessing network resources, credentials, or developer tooling).
  • Abuse of the local environment to stage further attacks or participate in broader campaigns.

General mitigation guidance

Effective mitigation centers on hardening the deeplink-to-configuration pipeline and limiting what imported configurations can do:

  • Require explicit, high-friction user confirmation when a deeplink attempts to add or modify an MCP server capable of running local commands, with clear risk signaling.
  • Treat all deeplink-originated configurations as untrusted by default; introduce trust levels and restrict high-privilege operations for untrusted sources.
  • Enforce strict validation of MCP server configurations, allowing only a constrained, well-defined set of operations and arguments.
  • Introduce sandboxing layers for any command execution paths, such as using restricted execution environments, and separate configuration parsing from execution logic.
  • Apply the principle of least privilege to any subprocesses or command runners spawned from MCP servers, minimizing their access to the file system and OS features.
  • Provide configuration options or policies to disable deeplink-based configuration import in high-security environments.

How teams detect issues like this

Detection strategies can focus on both code-level patterns and runtime behavior:

  • Static analysis & review:
  • Search for deeplink or custom URL handlers that directly or indirectly influence command execution or subprocess creation.
  • Flag flows where user-supplied configuration (from URLs or external files) is passed into command runners, interpreters, or plugin frameworks without robust validation.
  • Review logic around "one-click" or implicit approval flows for adding new MCP servers or integrations.
  • Runtime and operational monitoring:
  • Monitor application logs for unexpected MCP server registrations originating from deeplinks and correlate them with user actions.
  • Track and alert on unusual command execution patterns originating from the Dive application process.
  • Policy enforcement:
  • Implement development policies requiring explicit review for any feature that bridges external links or configuration with local execution capabilities.
  • Use automated code review tools or SAST that highlight configuration-driven execution paths and potential code injection points.

Sources

SourceLink
github.comgithub.com/OpenAgentPlatform/Dive/commit/a5162ac9eff366d8ea1215b8a47139a81a55a779
github.comgithub.com/OpenAgentPlatform/Dive/security/advisories/GHSA-pjj5-f3wm-f9m8

Frequently asked

questions

It is indirectly remote: an attacker can host or distribute a malicious deeplink over the internet, but the exploit still requires a local user to open that link with the Dive desktop application.

The attacker does not need prior access to the victim's machine; they only need to persuade the user to open a crafted deeplink. Once opened, the vulnerable configuration flow can lead to arbitrary local command execution under the victim's user account.

The safest approach is to decouple deeplink handling from powerful execution capabilities: treat deeplink-provided configurations as untrusted, require explicit and informed user consent before enabling any configuration that can execute commands, and constrain/sandbox execution so that configuration cannot directly translate into arbitrary code or command invocation.

Preventive measures include designing all external entry points (deeplinks, plugins, remote configs) with a strict trust model, enforcing schema validation, avoiding direct mapping from configuration to execution, and systematically applying least privilege and sandboxing around any feature that can trigger local commands or code.

Find out what's already
exploitable in your codebase.