Skip to content

A Single Click in Jan’s AI Chat Could Hand Over Your Computer

Parth ShuklaParth Shukla· AI Researcher8 min read

Key takeaways

  • Treat model and tool output as untrusted input, it’s attacker-controllable content, not a convenience to render verbatim.
  • A privileged window is no place for untrusted content; it must never navigate to or run content from an origin you don’t control.
  • Defense in depth is the whole game: any one of three missing guards here would have stopped the chain on its own.
  • Know your framework’s defaults: the sharpest edge came from an upstream Tauri default, pinning a version means inheriting its security posture.

A compromised AI tool could slip an ordinary-looking link into Jan’s chat. A single click replaced the app’s own window with an attacker page, handed it the app’s internal powers, and let it run any program on the user’s machine. No password, no second prompt.

ProductJan (janhq/jan)
ClassOne-click RCE via untrusted content
Affected<= 0.8.7
Fixed in0.8.8
SeverityCritical
CVSS 3.1 (assessed)9.6
AdvisoryGHSA-j6hv-vhmg-vpj6
CVEpending
CWECWE-94 / CWE-346 / CWE-1188

Executive summary#

Jan is a widely used open-source desktop app for running AI models offline. It can connect to MCP servers, external tools the model calls to do real work. A malicious or compromised MCP server (or prompt-injected tool output the model relays) could put a normal markdown link into the chat. Jan rendered that link as a live, same-frame link, had no guard stopping the main window from navigating away, and shipped without a permissions manifest for its internal commands.

Chained together, one click navigated Jan’s main window to an attacker-controlled page, which then inherited the app’s internal bridge and called the command that spawns processes, achieving remote code execution as the user. Fixed in v0.8.8; all versions <= 0.8.7 are affected.

Why this matters#

AI desktop apps have quietly become some of the most powerful programs on a user’s machine. They read files, run tools, and increasingly take actions through MCP, the standard that lets a model call external tools. That power comes with a new trust boundary that classic app security never had to think about: content produced by a model or a third-party tool is now rendered directly into a trusted, privileged window.

The industry has already seen where this leads. Prompt-injection chains like EchoLeak (CVE-2025-32711) turned a crafted email into silent data theft from an AI assistant. This finding is the next rung on the same ladder: not just data exfiltration, but full code execution, reached through the ordinary MCP tool feature working exactly as designed. The lesson generalizes to nearly every AI app built on a web stack (Electron or Tauri): if an untrusted model or tool output can steer a privileged window, a chat message becomes an exploit primitive.

Background: Jan, MCP, and the Tauri trust model#

Jan is an open-source, offline alternative to ChatGPT that runs models locally on your own machine. It is built by Menlo Research on the Tauri framework (a Rust backend with a web-based UI), and it is widely adopted.

  • 7.2M+ downloads (GitHub releases)
  • 45k+ GitHub stars
  • 100% runs offline, on-device

Two design facts set the stage. First, MCP servers are semi-trusted at best. Users add them to extend the model with tools, and those tools (or the model relaying their output) can return arbitrary text into the chat. Second, Tauri apps talk between the web UI and the Rust backend over an IPC bridge: the frontend calls backend commands over it. Which origins may call which commands are meant to be governed by a permissions manifest (an ACL). Jan shipped without one, which turns out to matter a great deal.

Key terms#

IPC (inter-process communication): The private channel the app’s visible UI (a web page) uses to ask its powerful backend to do real work, like reading a file or starting a program. Think of it as an intercom between the front desk and the back office. It is meant to be used only by the app’s own pages.

ACL (access control list) and the ACL bypass: An ACL is the guest list for that intercom: the rules saying which pages are allowed to request which backend actions. An ACL bypass is when the guest list fails to stop someone it should have. Here the app shipped with no guest list at all for its own commands, so in the pinned framework version any page, including the attacker’s, could pick up the intercom and order the back office to launch a program.

The vulnerability: three defenses, all missing#

No single bug here is fatal on its own. The severity comes from three independent weaknesses lining up so that untrusted chat content reaches the one backend command that can start a process.

  1. Untrusted content is rendered as a live link. The chat’s markdown renderer has link safety switched off and turns any ordinary URL into a plain same-frame link: no new window, no hand-off to the system browser, no click interceptor. A tool returning [open report](http://attacker.tld) gets a link that navigates Jan’s own window.
  2. Nothing guards navigation. Neither the backend nor the UI checks where the window is allowed to go. Tauri permits navigation by default, so one click moves the main window to the attacker’s origin.
  3. The remote page inherits the IPC bridge. Tauri injects its IPC bootstrap, including the per-session invoke key, into every page the main window loads, with no origin check. The attacker’s page gets the same bridge the app’s own UI uses, and the backend’s only check on an incoming call is that key.
  4. The app-command ACL is bypassed (the core issue). Jan ships no permissions manifest for its own commands. In the Tauri version Jan built against (2.10.3), the ACL check ran only for plugin commands or for apps that had a manifest. An app command with no manifest was never checked, so a remote origin could call it:
if command belongs to a plugin OR app has a manifest:
    require a matching ACL entry      # remote page rejected
else:
    allow                             # Jan's case: any origin

Tauri closed this in 2.11.1 (PR #15266); the changelog says custom commands “bypassed ACL entirely without an AppManifest, allowing any origin to invoke them.”

See it in action.

5. A backend command spawns an arbitrary process. The backend command that starts an MCP server takes the program, arguments, and environment straight from its caller and launches them, with no allowlist. Called from the attacker’s page, that is code execution as the user.

The attack chain

Figure 1: The attack chain. Break any one link in this chain and the attack fails.

Proof of concept#

The entire exploit is a link plus a tiny page. When the user clicks, the attacker’s page runs one line against the app’s internal bridge. See the full reproduction in the published advisory GHSA-j6hv-vhmg-vpj6. The payload used for the demo is a harmless touch /tmp/jan_pwned to prove execution; substitute any command and it runs with the user’s privileges. After the single click there is no prompt and no confirmation. The attack works from any origin because app commands skip the ACL entirely; it does not depend on the app’s capability allowlist. All testing was local and non-destructive against the open-source build.

Impact#

Remote code execution as the user is the ceiling, the most severe outcome a vulnerability can have. Once a process spawns, the attacker can read and exfiltrate local files (including the user’s model data, API keys, and credentials), install persistence, pivot to other systems, or deploy ransomware, all with the victim’s privileges.

Who is exposed#

Any Jan user who connects the app to a third-party MCP server, which is the intended way to use the feature. The malicious content does not require the user to visit a shady website: the model relaying a poisoned tool result can deliver the link inside a normal-looking answer, so even a careful user who only ever talks to their own assistant can be hit if one connected tool is compromised or prompt-injected.

Preconditions and blast radius#

The one precondition is a single user click on a link in the chat, a routine action. Everything else is the default build: no special configuration, no non-default toggle. Affected versions are <= 0.8.7 across all platforms Jan ships.

Root cause#

This is a defense-in-depth collapse, not one careless line. A privileged desktop app should assume that model and tool output is hostile and keep several independent barriers between that content and any dangerous capability. Jan had three natural barriers, and all three were open at once: link rendering did not neutralize untrusted links, navigation was not constrained to the app’s own origin, and the IPC layer had no permissions manifest to deny remote callers. The upstream Tauri framework contributed the sharpest edge: in the pinned version, custom app commands with no manifest were callable by any origin, a primitive the Tauri team themselves later closed. Each barrier alone would have broken the chain; the finding exists because none were present on the path the content actually took.

Remediation#

Jan fixed this in v0.8.8. The chain breaks at any link, so a robust fix closes several:

  • Add a navigation guard so the main window cannot navigate to non-app origins.
  • Open model and tool links in the system browser or behind an interstitial, never as a live same-frame link.
  • Ship an app permissions manifest so backend commands are ACL-gated and deny remote origins by default.
  • Upgrade Tauri to 2.11.1 or later, which closes the app-command ACL bypass for remote origins.
  • Allowlist what the MCP server launcher command may execute.

What users should do#

  • Update Jan to v0.8.8 or later. This is the single most important step.
  • Review your connected MCP servers and remove any you do not fully trust.
  • Be wary of clicking links inside AI chat output, especially from sessions that use external tools.

Detection#

On an unpatched build, signs of exploitation include the Jan main window navigating to an unexpected external origin, and child processes spawned by Jan that do not correspond to a configured MCP server binary. Monitoring process creation with Jan as the parent is the clearest signal.

Disclosure timeline#

  • 2026-08-26 Reported: Privately disclosed to the Jan team through GitHub’s coordinated vulnerability reporting channel, with a full chain write-up and local PoC.
  • 2026-10-29 Fixed: Patched and released in Jan v0.8.8.
  • 2026-10-29 Advisory: GHSA-j6hv-vhmg-vpj6 published; 0xParth credited as reporter.
  • Pending: CVE identifier awaiting assignment. This post will be updated when it lands.

Key takeaways#

  1. Treat model and tool output as untrusted input. It arrives from outside your trust boundary, the same as anything off the network. A link in a chat is attacker-controllable content, not a convenience to render verbatim.
  2. A privileged window is no place for untrusted content. If a webview holds the keys to the OS, it must never be allowed to navigate to, or execute content from, an origin you do not control.
  3. Defense in depth is the whole game. Any one of three guards here would have stopped the chain. Single-layer security against AI-supplied content is not enough, because the content is adversarial by assumption.
  4. Know your framework’s defaults. The sharpest edge came from an upstream default (ungated app commands without a manifest). Pinning a framework version means inheriting its security posture; track its advisories as closely as your own.
Parth Shukla

Parth Shukla

AI Researcher

Parth is an Offensive Security Engineer at Metano. He breaks the AI ecosystem, then builds what keeps it from breaking.