Skip to main content

kitty CVE-2026-95835

| EUVDEUVD-2026-87239 MEDIUM
Missing Authorization (CWE-862)
2026-09-25 Secur0 GHSA-c73q-fvjv-39j2
5.6
CVSS 4.0 · Vendor: Secur0
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain a local user account on shared host
  2. Delivery
    Create SHM object victim can read/write, inject DCS bytes into victim terminal
  3. Exploit
    kitty askpass renders attacker's masked prompt
  4. Execution
    Victim types secret, kitty writes it to the named object
  5. Impact
    Attacker reads disclosed secret from shared memory

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization checks on every request
MITRE ATT&CK

1 technique across 1 tactic: Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires: (1) the attacker to be a separate local user on the same host as the victim, with no privilege on the victim's account; (2) a POSIX shared-memory namespace shared between the two users (e.g. a shared /dev/shm), so the attacker can create an object the victim can open and both read/write; (3) the ability to cause attacker-chosen bytes - a device control string - to be displayed in the victim's kitty terminal (e.g. victim views a crafted file, log, or command output); (4) the victim running kitty version 0.25.0 up to before 0.49.0; and (5) the victim actually answering the rendered prompt (UI:A) by typing the secret. Limiting factors: hosts where the SHM namespace is not shared between users, single-user workstations, or kitty >= 0.49.0 are not exploitable; the ssh kitten path was never vulnerable because it already verified owner and permissions.

Impact

This is a genuine but tightly-bounded local information-disclosure flaw, not a high-severity remote priority. The provided CVSS 4.0 vector (AV:L/AC:L/AT:P/PR:L/UI:A/VC:H/VI:L/VA:N/SC:H, base 5.6) is internally consistent and well-matched to the description: local attack vector, an existing local account (PR:L), an attack requirement (AT:P - the POSIX SHM namespace must actually be shared between the two users), and active victim interaction (UI:A - the victim must type a secret into the prompt). The high confidentiality impact (VC:H) plus subsequent-system confidentiality (SC:H) correctly reflect that a secret crosses a user-isolation boundary. No EPSS score, no CISA KEV listing, and no public exploit are present in the input - exploitation status is 'no public exploit identified at time of analysis'. The multiple stacked preconditions (shared SHM namespace + ability to inject attacker-chosen bytes into the victim's terminal + victim answering the prompt) make opportunistic mass exploitation implausible; this is a targeted, same-host scenario. There are no conflicting signals in the data: the description, the CVSS vector, and the patch diff (which adds an ownership/permission check identical to the one the ssh kitten already had) all agree that this is a local authorization gap. Overall: real and worth patching on multi-user hosts, but low-to-medium operational priority.

Exploit ScenarioDerived

On a multi-user Linux host where /dev/shm is shared, a second local user creates a POSIX shared-memory object with permissions allowing the victim to read and write it, then causes attacker-controlled bytes (a device control string) to be rendered in the victim's kitty terminal - for example by getting the victim to view a crafted file or log. The victim's kitty renders an attacker-defined masked password prompt; when the victim types their secret, kitty writes it back into the same named object, and the attacker reads it out. No public exploit code is identified, and the attack requires the attacker to already have a local account and to induce the byte display and a victim answer.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 25, 2026

Secret disclosure in kitty 0.25.0 through versions before 0.49.0 lets a second local user on the same host capture text that the victim types into prompts rendered by kitty itself, including masked password prompts, without holding any privilege on the victim's account. The askpass escape-code handler in kitty/window.py (handle_remote_askpass) opens a POSIX shared-memory object named in an attacker-supplied device control string and later writes the typed answer back into an object of that same name, never verifying that the object is owned by the user running kitty or that its permissions exclude other users, unlike the equivalent ssh kitten path which performs exactly that check. Exploitation is tightly bounded: it requires a POSIX shared-memory namespace shared between attacker and victim, attacker-influenced bytes being displayed in the victim's terminal, and the victim actually answering the rendered prompt; no public exploit code has been identified at time of analysis and this CVE is not in CISA KEV, and hosts with isolated shared memory, single-user workstations, and kitty 0.49.0 or later are not affected.

RemediationAI

Vendor-released patch: upgrade to kitty 0.49.0 or later, which is the release that carries the fix; the underlying change is commit 3281919056c442e4ba6f5abed7ee2c5130de31ff, which adds SharedMemory.verify_owner_and_mode() in kitty/shm.py, calls it from handle_remote_askpass() in kitty/window.py in place of the unchecked open, unlinks the shared-memory object before use, and sanitises control codes in the prompt text. See the release notes at https://github.com/kovidgoyal/kitty/releases/tag/v0.49.0 and the advisory at https://secur0.com/en/cna/cve-list/cve-2026-95835-kitty-askpass-shared-memory-ownership. Where upgrading is not immediately possible, the exploitable precondition is a shared POSIX shared-memory namespace between users: isolating /dev/shm per user or per session (for example by giving each session a private mount namespace, or restricting multi-user access to the shared /dev/shm) breaks the attack entirely, at the cost of losing cross-process shared-memory interoperability for other legitimate applications on that host. Users can also reduce exposure by never answering askpass-style prompts (password, confirmation, or choose dialogs) that they did not personally initiate, and by avoiding displaying untrusted files, logs, or command output in kitty, since the attacker must still get a device control string rendered by the victim's terminal; both are behavioral controls with no system side effects but they are not reliable substitutes for the patch. Note that kitty 0.49.0 or later, single-user workstations, and hosts with per-user shared-memory isolation are not exploitable, and the ssh kitten code path requires no separate action because it already verified object ownership and permissions.

Affected VersionsENISA

kitty 0.25.0 <0.49.0

Affected Packages

euvd kitty fix: 0.49.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The root cause is CWE-862 (Missing Authorization): kitty's SharedMemory abstraction (kitty/shm.py) opens POSIX shared-memory objects by name, and the askpass consumer inside handle_remote_askpass() in kitty/window.py accepted a name taken directly from an untrusted device control string in the terminal byte stream without validating the object's owner or mode. Because anyone who can write to the shared POSIX shared-memory namespace (typically /dev/shm) can pre-create an object under a chosen name with permissions that let the victim process read and write it, the attacker controls both the prompt definition parsed out of the object and the buffer the victim's answer is stored into; the handler reopens the object by name on answer rather than reusing the already-held handle. The parallel code path in the ssh kitten (kittens/ssh/utils.py) already called verify_owner_and_mode(), checking st_uid/st_gid against os.geteuid()/os.getegid() and requiring mode exactly 0o600, and the fix lifts that check into a reusable SharedMemory.verify_owner_and_mode() method and calls it from the askpass path. A secondary weakness in the same commit is that prompt text was passed to the display without control-character sanitisation, allowing the prompt to overwrite the warning line kitty prints above it; the patch adds sanitize_control_codes() for the message, choices, and prompt fields and unlinks the shared memory object before use so no other user can open it while kitty holds it.

Know when Kitty gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (Secur0) PRIMARY 5.6 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:P/PR:L/UI:A/VC:H/VI:L/VA:N/SC:H/SI:N/SA:N
vuln.today AI 6.1 MEDIUM

Local attacker with own account (PR:L); AC:H for stacked preconditions (shared SHM namespace + byte injection); UI:R as victim must type the secret; S:C as disclosure crosses the user boundary; C:H, minor I:L (prompt overwrite), no availability impact.

3.1 AV:L/AC:H/PR:L/UI:R/S:C/C:H/I:L/A:N
4.0 AV:L/AC:L/AT:P/PR:L/UI:A/VC:H/VI:L/VA:N/SC:H/SI:N/SA:N
SUSE MEDIUM

Primary rating from Vendor (Secur0).

CVSS VectorVendor: Secur0

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
Low
User Interaction
Active
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
Low
Vulnerable system: Availability
None
Subsequent system: Confidentiality
High
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Missing Authorization in the askpass escape code handler in kitty from 0.25.0 before 0.49.0 allows a local user other than the one running the terminal to obtain the text typed into a prompt that kitty itself displays, because handle_remote_askpass() in kitty/window.py opens the POSIX shared memory object named in the escape code, parses a prompt definition out of it, and writes the user's answer back into an object of that same name, without at any point checking that the object is owned by the user running kitty or that its permissions exclude other users. The equivalent consumer of the same SharedMemory class in the ssh kitten performs exactly that check; the askpass path did not. The handler is reached through a device control string processed from the byte stream of the window, so the attacker must also cause bytes of their choosing to be displayed by the victim's terminal. Where the POSIX shared memory namespace is shared between the two users, a second local user can create an object with permissions that allow the victim to read and write it, cause the victim's kitty to render a prompt of the attacker's choosing, including a masked password prompt, and read the typed secret back out of the object afterwards. The prompt text is additionally passed to the display without control character sanitisation, so it can overwrite the warning line kitty prints above it. The answer is written by reopening an object of that name when the user answers, rather than through the handle already held. This results in disclosure of a secret typed by the victim to a second local user, and does not require any privilege on the victim's account.

Threat Intelligence Overview

EPSS Score
0.1%
Top 99% exploitable
Prevalence
Medium
Popular GPU-accelerated terminal among Linux/macOS developers, not universally deployed
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor CIRCL GitHub

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

28
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +28
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

More in Kitty

View all
CVE-2023-48795 MEDIUM POC
5.9 Dec 18

The SSH transport protocol with certain OpenSSH extensions, found in OpenSSH before 9.6 and other products, allows remot

CVE-2016-2563 CRITICAL POC
9.8 Apr 07

Stack-based buffer overflow in the SCP command-line utility in PuTTY before 0.67 and KiTTY 0.66.6.3 and earlier allows r

CVE-2020-35605 CRITICAL POC
9.8 Dec 21

The Graphics Protocol feature in graphics.c in kitty before 0.19.3 allows remote attackers to execute arbitrary code bec

CVE-2024-23749 HIGH POC
7.8 Feb 09

KiTTY versions 0.76.1.13 and before is vulnerable to command injection via the filename variable, occurs due to insuffic

CVE-2024-25004 HIGH POC
7.8 Feb 09

KiTTY versions 0.76.1.13 and before is vulnerable to a stack-based buffer overflow via the username, occurs due to insuf

CVE-2024-25003 HIGH POC
7.8 Feb 09

KiTTY versions 0.76.1.13 and before is vulnerable to a stack-based buffer overflow via the hostname, occurs due to insuf

CVE-2022-41322 HIGH POC
7.8 Sep 23

In Kitty before 0.26.2, insufficient validation in the desktop notification escape sequence can lead to arbitrary code e

CVE-2026-33642 CRITICAL
9.8 May 19

Heap memory corruption in Kitty cross-platform GPU terminal emulator (versions 0.46.2 and below) allows remote attackers

CVE-2026-33633 HIGH
8.8 May 19

Heap buffer overflow in Kitty terminal versions 0.46.2 and below allows any process able to write to the terminal's stan

CVE-2025-43929 MEDIUM POC
4.1 Apr 20

open_actions.py in kitty before 0.41.0 does not ask for user confirmation before running a local executable file that ma

CVE-2026-42851 HIGH
7.8 Jun 12

Remote code execution in Kitty terminal emulator versions prior to 0.47.0 allows any process or remote peer that can wri

CVE-2026-42850 HIGH
7.4 Jun 12

Command injection in Kitty cross-platform GPU terminal emulator versions prior to 0.47.0 allows remote attackers to exec

Vendor StatusVendor

SUSE

Severity: Moderate

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy