/

CVE-2026-48704

Severity:

HIGH RISK

(8.8)

Input Validation Flaw (CWE-20) in Warp Link Handling

CVE-2026-48704

Deferred

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Unintended Local Code Execution / Privilege Misuse

Severity:

HIGH RISK

(8.8)

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

Warp's agentic development environment improperly handles local-file links embedded in Markdown documents and projects, allowing them to be opened with the operating system's default file handler.

When a user clicks such a link in affected builds, Warp may route the local file to an executable handler instead of a safe viewer/editor, which can lead to unintended execution of local programs or scripts under the user's context.

Affected context

This vulnerability arises in Warp installations that render Markdown or project content containing links to local files on the user's machine.

Instead of constraining link targets to non-executable viewers or editors, affected versions may delegate the resolved path to the platform's default file opener.

Risk increases in workflows where users open untrusted or shared Markdown documents, project files, or documentation that could embed local-file links to executable content.

Exploit preconditions

  • Attack surface: User interaction within Warp's UI, specifically clicking rendered links in Markdown or project views.
  • Required access: Ability for an attacker to supply or influence Markdown content or project files viewed in Warp (e.g., repository content, shared documentation).
  • Trigger point: The moment a user clicks a malicious local-file link rendered as normal content inside Warp.
  • Why exploitation is possible: Warp does not adequately validate or constrain which local-file links may be opened via the operating system's default handler, allowing executable targets to be launched without clear user intent.

Why this happens

The core issue is an input validation and enforcement failure around link handling.

Warp treats link targets embedded in Markdown or project files as trusted, routing local-file URIs to the operating system's default file opener without verifying whether they point to executable resources or restricting the action to safe viewer/editor applications.

This maps to CWE-20: Improper Input Validation, where application logic fails to enforce constraints on external inputs (link targets) before acting on them, resulting in unsafe behavior.

Potential impact

  • User may unintentionally launch local executables, scripts, or installers from within Warp.
  • Execution of attacker-selected code already present on the filesystem (e.g., bundled tools, scripts in project directories).
  • Abuse of the user's privileges to perform actions via launched applications (configuration changes, file modifications, or network access).
  • Increased risk of social-engineering attacks within development workflows using seemingly benign documentation.

General mitigation guidance

Effective mitigation focuses on hardening how local-file links are interpreted and acted upon inside development tools.

General defensive patterns include:

  • Validating link targets before opening them, limiting supported schemes and disallowing direct execution paths for local files.
  • Constraining link handling to safe viewer or editor applications rather than generic OS file openers, especially when the content source may be untrusted.
  • Introducing explicit user consent flows (clear prompts or warnings) when a link may result in launching an executable or privileged application.
  • Reducing implicit trust in workspace and documentation content by treating embedded links as untrusted input and applying security policies consistently.

How teams detect issues like this

Detection typically involves reviewing how UI components and content renderers resolve and open links or external resources.

High-level approaches include:

  • Static analysis or manual code review to identify calls that delegate local-file paths to OS-level openers without validation or filtering.
  • Auditing Markdown and project rendering pipelines for missing checks on URI schemes, file extensions, and target application types.
  • Implementing internal policy checks that flag code paths where user-generated or repository-sourced content can trigger OS-level actions.
  • Using automated security review tools to search for patterns of unsafe resource opening or insufficient input validation around user-clickable elements.

Sources

SourceLink
github.comgithub.com/warpdotdev/warp/commit/7f0c4dd2322198f1b39890f8e6bcdc606c6a3c74
github.comgithub.com/warpdotdev/warp/security/advisories/GHSA-589x-4mxh-jcrf

Frequently asked

questions

It relies on user interaction, but an attacker can remotely supply malicious Markdown or project files (for example via source repositories or shared documentation) that, when opened in Warp and clicked, cause local executables to run.

The attacker must be able to influence or provide content that the user will open in Warp, such as a cloned repository, downloaded project, or shared Markdown document. They do not need direct access to the victim's machine beyond that.

The safest approach is to treat all embedded links as untrusted input, validate and restrict the schemes and paths that can be opened, and ensure that local-file links are only routed to non-executable viewer/editor targets or require explicit, informed user consent before any potentially executable resource is launched.

Design link and resource handling subsystems under a principle of least privilege for user actions: strictly validate inputs, segregate executable actions from passive viewing, enforce clear prompts for high-risk operations, and include security-focused code review and automated checks around any UI features that can trigger OS-level behavior.

Find out what's already
exploitable in your codebase.