/

CVE-2026-45035

Severity:

HIGH RISK

(8.8)

Command Injection in Tabby Terminal Emulator

CVE-2026-45035

Analyzed

Vulnerability type

Category:

Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution via URL Scheme Handler

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

Tabby's custom URL scheme handler (tabby://) exposes a command execution feature that directly runs OS commands from crafted links without any confirmation or sanitization.

When a victim clicks a malicious tabby://run?command=... link, Tabby is launched and immediately spawns the specified command with the user's full privileges, enabling remote code execution with no additional interaction.

Affected context

This vulnerability affects environments where Tabby (formerly Terminus) is installed and has registered itself as the default handler for the tabby:// URL scheme.

The risk is most pronounced on systems where:

  • Web browsers, email clients, messengers, or documentation tools allow launching custom URL schemes, and
  • Users routinely click application-specific links (e.g., from web dashboards, tickets, or internal tools).

In such contexts, Tabby's URL handler treats incoming tabby://run links as trusted instruction channels rather than untrusted, potentially hostile input.

Exploit preconditions

  • Attack surface: Any medium that can deliver clickable links (web pages, emails, chat messages, documents, or desktop shortcuts) that the OS routes to the tabby:// handler.
  • Required access: Ability to convince a user to visit or click a specially crafted tabby://run?command=... link; no prior access to the victim system is required.
  • Trigger point: The moment the OS resolves the tabby:// URL and launches Tabby; Tabby automatically processes the run command parameter and spawns a child process.
  • Why exploitation is possible: The URL handler accepts arbitrary command strings, passes them directly to the OS command execution mechanism without validation, confirmation, or sandboxing, and runs them with the privileges of the logged-in user.

Why this happens

The underlying issue is an unvalidated command construction from input, mapping directly to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

Tabby's URL scheme handler exposes a run action that interprets query parameters as command-line instructions.

Instead of treating URL parameters as untrusted data and validating, constraining, or mediating them, the application forwards the supplied command string to the operating system for execution.

The absence of:

  • Input validation or command whitelisting,
  • Prompting the user for consent,
  • Isolation or sandboxing of launched commands,

turns the URL handling mechanism into a remote execution primitive whenever a user follows a crafted tabby://run link.

Potential impact

  • Execution of arbitrary OS commands with the full privileges of the user running Tabby.
  • Installation of malware, backdoors, or persistence mechanisms on the affected system.
  • Exfiltration of sensitive data accessible to the user, such as SSH keys, configuration files, or local credentials.
  • Lateral movement within corporate or cloud environments using the user's existing credentials and configurations.
  • Modification of system settings, developer environments, or terminal configurations to weaken security posture for future attacks.

General mitigation guidance

Mitigation centers on removing implicit trust in URL-triggered commands and separating control channels from untrusted input.

High-level defensive patterns include:

  • Introduce explicit user consent: Require a clear, focused confirmation dialog before executing commands received via URL handlers, displaying the exact command to be run.
  • Constrain allowed commands: Implement a whitelist of permitted actions (e.g., open a specific profile/session) instead of passing raw OS command strings from the URL.
  • Use structured, non-executable parameters: Represent allowed operations as high-level actions with arguments (e.g., JSON or key-value options) and map them to safe internal APIs rather than shell commands.
  • Sanitize and validate inputs: Reject or strictly parse input that includes shell metacharacters, redirections, pipelines, or other constructs indicative of arbitrary command execution.
  • Apply least privilege: Where feasible, run the URL handler logic in a constrained context (e.g., reduced privileges, separate helper process) to limit damage if misuse occurs.
  • Allow opt-out or hardened configuration: Provide settings for administrators and users to disable dangerous URL actions or limit them to local-only or pre-approved use cases.

How teams detect issues like this

Detection often involves both code-level analysis and runtime monitoring:

  • Static analysis and code review:
  • Search for URL scheme handler registration and follow the code paths that process incoming URLs.
  • Flag any logic that constructs shell commands from URL parameters or user-controlled strings.
  • Look for direct use of shell execution APIs (exec, spawn, system, or equivalent) in URL-related modules without intermediate validation.
  • Security-focused code review checklists:
  • Treat custom URL schemes as untrusted entry points, similar to network sockets or HTTP endpoints.
  • Verify that any "run" or "execute" style capabilities are not reachable via untrusted input without confirmation.
  • Automated tooling:
  • Configure linters or security scanners to highlight dynamic command construction based on external input.
  • Use application instrumentation or logging to identify unexpected tabby://run invocations, especially those originating from external sources.
  • Policy enforcement:
  • Establish organizational policies requiring security review for new URL handlers, integration hooks, or "single-click" execution features.

Sources

SourceLink
github.comgithub.com/Eugeny/tabby/security/advisories/GHSA-hf8h-rjrf-3jg6

Frequently asked

questions

Yes, in practice it is remotely exploitable: an attacker can host or embed a tabby://run link on a website or in any shared content. When a user with Tabby installed clicks that link (or when the environment automatically follows it), the OS invokes Tabby, which executes the supplied command on the user's machine.

The attacker's commands run with the same privileges as the user account that launches Tabby. In typical desktop environments, this means the attacker can perform any action the user can, including reading and modifying files, accessing developer tools, and using stored credentials.

The safest pattern is to avoid exposing raw command-execution capabilities through URL handlers altogether. If command-like behavior is required, map URLs to a limited set of predefined actions, require explicit user confirmation before potentially dangerous operations, and handle all input as data passed to internal APIs rather than to shell interpreters.

Treat all external triggers—custom URL schemes, deep links, IPC endpoints, and plugin APIs—as untrusted interfaces. Apply secure design principles by:

  • Designing minimal, data-oriented protocols instead of command strings.
  • Applying strict input validation and whitelisting.
  • Incorporating security reviews for any feature that can execute commands or change system state in response to a single user action.
  • Integrating static analysis and secure coding guidelines into the development lifecycle to catch unsafe command execution pathways early.
Find out what's already
exploitable in your codebase.