Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain a local user account on shared host
-
DeliveryCreate SHM object victim can read/write, inject DCS bytes into victim terminal
-
Exploitkitty askpass renders attacker's masked prompt
-
ExecutionVictim types secret, kitty writes it to the named object
-
ImpactAttacker 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (Secur0).
CVSS VectorVendor: Secur0
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
The SSH transport protocol with certain OpenSSH extensions, found in OpenSSH before 9.6 and other products, allows remot
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
The Graphics Protocol feature in graphics.c in kitty before 0.19.3 allows remote attackers to execute arbitrary code bec
KiTTY versions 0.76.1.13 and before is vulnerable to command injection via the filename variable, occurs due to insuffic
KiTTY versions 0.76.1.13 and before is vulnerable to a stack-based buffer overflow via the username, occurs due to insuf
KiTTY versions 0.76.1.13 and before is vulnerable to a stack-based buffer overflow via the hostname, occurs due to insuf
In Kitty before 0.26.2, insufficient validation in the desktop notification escape sequence can lead to arbitrary code e
Heap memory corruption in Kitty cross-platform GPU terminal emulator (versions 0.46.2 and below) allows remote attackers
Heap buffer overflow in Kitty terminal versions 0.46.2 and below allows any process able to write to the terminal's stan
open_actions.py in kitty before 0.41.0 does not ask for user confirmation before running a local executable file that ma
Remote code execution in Kitty terminal emulator versions prior to 0.47.0 allows any process or remote peer that can wri
Command injection in Kitty cross-platform GPU terminal emulator versions prior to 0.47.0 allows remote attackers to exec
EUVD-2026-87239
GHSA-c73q-fvjv-39j2
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB