Summary
Tabby's terminal linkifier forwards any detected URI directly to the operating system's protocol handler without validating the URI scheme.
A malicious SSH or Telnet server can emit crafted terminal output that appears as clickable links in Tabby, causing dangerous protocol handlers (such as custom or less common schemes) to be triggered on the victim's machine.
Affected context
The vulnerability appears when Tabby is used as a terminal emulator connected to potentially untrusted remote systems (e.g., SSH, Telnet, or other remote shells).
When these servers print text that looks like URIs, Tabby's linkifier automatically converts them into clickable links and delegates handling to the underlying operating system.
Because there is no scheme-level allowlist or validation, any protocol supported on the user's system can be invoked if the user clicks the link.
Exploit preconditions
- Attack surface: User's Tabby terminal session displaying remote output.
- Required access: Ability to control or influence text printed to the user's Tabby terminal (e.g., as an SSH/Telnet server operator, or via commands executed on the remote host).
- User interaction: The user typically needs to click the rendered link for the protocol handler to be triggered.
- Trigger point: Tabby's linkifier detects a URI-like pattern and forwards it directly to the OS protocol handler.
- Why exploitation is possible: The linkifier does not validate or restrict URI schemes, so untrusted output can invoke arbitrary registered protocol handlers on the local system.
Why this happens
The issue stems from treating all URI-like text in terminal output as equally safe and delegating them directly to the OS without validation.
This maps to CWE-184: Improper Input Validation, where the application fails to enforce constraints on untrusted data—in this case, URI schemes and targets—before using it.
It is closely related to CWE-601: Open Redirect, because untrusted endpoints (protocol handlers) are effectively chosen by an attacker and followed by the client without restriction.
At a design level, the linkification feature lacks a trust boundary between remote terminal content and local system capabilities, allowing remote text to control which local applications or handlers are launched.
Potential impact
- Launching arbitrary registered protocol handlers on the user's system.
- Triggering dangerous or poorly secured custom application protocols.
- Coaxing users into opening attacker-controlled websites, resources, or applications.
- Facilitating phishing, credential theft, or social-engineering attacks via deceptive links in terminal output.
- Potential lateral movement or data exfiltration if a triggered handler performs sensitive operations without sufficient prompts.
General mitigation guidance
Mitigation generally focuses on tightening how terminal output is transformed into actionable links and reducing trust in remote content.
Common defensive patterns include:
- Implementing a strict allowlist of safe URI schemes (e.g., https, http, ssh) and blocking or warning for all others.
- Introducing confirmation prompts or clear warnings when non-standard or high-risk schemes are invoked.
- Providing configuration options to disable linkification entirely or restrict it to known-safe contexts.
- Normalizing, sanitizing, and validating all URI-like text against a canonical, well-defined parser before passing it to the OS.
- Designing the UI so that links originating from untrusted terminal output are visually distinguishable from trusted UI elements.
These measures reduce the risk that remote systems can trigger sensitive local capabilities through simple text output.
How teams detect issues like this
Detection focuses on identifying unsafe URI handling paths and validating linkification behavior:
- Static analysis: Search for code paths that pass terminal-output-derived strings directly into OS-level URL or protocol-launch APIs without scheme checks or validation.
- Code review: Flag implementations where linkification is applied to untrusted text (e.g., remote terminal output) without a scheme allowlist, normalization, or user confirmation.
- Runtime testing: Use security test cases where malicious or unusual URI schemes are printed in a test terminal session to verify how the application handles them.
- Policy enforcement: Establish guidelines for UI components that generate clickable links from untrusted content, requiring explicit validation and safe defaults.
Automated review tools can be configured to highlight patterns where user-facing links are derived from external or untrusted sources without sufficient checks.

