Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessStage malicious APC payload in file or remote output
-
DeliveryLure user to display untrusted content in Kitty
-
ExploitTerminal parses APC graphics command with f=100
-
ExecutionOversized PNG payload overflows load_image_data() heap buffer
-
PersistAttacker-controlled bytes corrupt heap metadata
-
ImpactCrash terminal or hijack execution in Kitty process
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the attacker can write bytes to the Kitty process's stdin or controlling TTY, the target must be running Kitty 0.46.2 or earlier, and Kitty's graphics protocol must be enabled (it is on by default). The attacker must deliver a single APC graphics protocol command with the PNG format declaration f=100 carrying a payload larger than twice load_image_data()'s initial buffer capacity. Limiting factors per CVSS AV:N/AC:H/UI:R: high attack complexity and required user interaction - the victim has to perform an action that pipes attacker-controlled output into Kitty (viewing a malicious file, SSHing to a compromised host, tailing a poisoned log, or running a hostile local program); no authentication to Kitty itself is required (PR:N) and scope is unchanged. |
| Impact | The CVSS 3.1 vector AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H yields 7.5 (High) and signals an unauthenticated network-reachable attack but with high complexity and required user interaction - realistic because exploitation requires getting attacker-controlled bytes piped into a victim's terminal stdin (e.g., catting a malicious file, viewing a crafted log over SSH, or a hostile process on the same host). EPSS and CISA KEV status were not supplied in the input, and no public exploit identified at time of analysis, so this is not currently a mass-exploitation candidate; the realistic risk profile is targeted abuse against developers, sysadmins, and CTF/forensics workflows where untrusted output is commonly displayed. The vendor confirms DoS is reliably triggerable and notes RCE is potentially reachable given the attacker-controlled length and content, but no public weaponization demonstrating code execution has been provided in the references - RCE remains an inferred upper bound, not a confirmed capability. |
| Exploit ScenarioDerived | An attacker who can place bytes into a user's terminal stdin - for instance via a malicious file the user runs |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 19, 2026
Heap buffer overflow in Kitty terminal versions 0.46.2 and below allows any process able to write to the terminal's standard input to crash the application and potentially achieve remote code execution. The flaw lives in load_image_data() and is triggered by a single APC graphics protocol command declaring PNG format (f=100) with a payload exceeding twice the initial buffer capacity, giving the attacker control over both overflow length and content. No public exploit identified at time of analysis, but the vulnerability has been fixed upstream in version 0.47.0.
RemediationAI
Vendor-released patch: upgrade Kitty to version 0.47.0 or later, available from the project's GitHub releases and referenced in advisory GHSA-j68c-v8x4-269g (https://github.com/kovidgoyal/kitty/security/advisories/GHSA-j68c-v8x4-269g). Until upgrade is possible, treat terminal stdin as an attack surface: avoid catting or paging untrusted files, log streams, or remote command output through Kitty; pipe untrusted output through filters that strip APC sequences (e.g., less with -R disabled, or wrap with cat -v) at the cost of losing legitimate inline graphics; and where feasible disable the graphics protocol via the allow_remote_control and graphics-related configuration to remove the affected code path, accepting the loss of icat/image preview functionality. SSH and tmux sessions that forward output from untrusted hosts should be considered exposure vectors and locked down accordingly.
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
Kitty is a GPU-accelerated, cross-platform terminal emulator written in C (cpe:2.3:a:kovidgoyal:kitty) that implements its own graphics protocol using APC (Application Program Command) escape sequences. The protocol lets clients embed images directly inside terminal output, with the f=100 parameter signaling that the payload is PNG-encoded image data. The vulnerability is a CWE-122 heap-based buffer overflow inside load_image_data(): the routine reserves an initial heap buffer for the decoded image but fails to bound subsequent payload chunks, so a payload larger than twice the initial capacity overruns the allocation. Because the bytes written come straight from the attacker's APC command, both the size and content of the overwrite are attacker-controlled, which is exactly the precondition for heap corruption escalation. The upstream fix commit (e9661f0) also widens related dimension variables in handle_compose_command from unsigned int to uint64_t to prevent integer overflow during validity checks, indicating tightening across the graphics command path.
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
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Primary rating from NVD.
CVSS VectorNVD
Lifecycle Timeline
2DescriptionNVD
Kitty is a cross-platform GPU based terminal. Versions 0.46.2 and below contain a heap buffer overflow in load_image_data() that allows any process which can write to the terminal's stdin to crash kitty immediately. The vulnerability is triggered by a single APC graphics protocol command with a PNG format declaration (f=100) whose payload exceeds twice the initial buffer capacity. The overflow is attacker-controlled in both length and content, causing DoS and potentially escalation to RCE itself. This issue has been fixed in version 0.47.0.
Executive ViewAI
Kitty terminal emulator versions 0.46.2 and earlier contain a high-severity heap buffer overflow in the graphics protocol handler that can crash the application or enable code execution when processing malicious terminal input. Organizations using Kitty face service disruption and unauthorized code execution risks if terminals process untrusted data.
Apply vendor patch: upgrade to Kitty 0.47.0 or later.
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
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.
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
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
Code injection in Kitty terminal emulator versions prior to 0.47.3 allows attacker-controlled bytes - including newline
Same weakness CWE-122 – Heap-based Buffer Overflow
View allSame technique Buffer Overflow
View allVendor StatusVendor
SUSE
Severity: Important| Product | Status |
|---|---|
| openSUSE Leap 16.0 | Fixed |
EUVD-2026-30964
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB