CVE-2026-134036 in Kritainfo

Summary

by MITRE • 11/20/2026

Krita ABR File Parsing Heap-based Buffer Overflow Remote Code Execution Vulnerability. This vulnerability allows remote attackers to execute arbitrary code on affected installations of Krita. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file.

The specific flaw exists within the parsing of ABR files. The issue results from the lack of proper validation of the length of user-supplied data prior to copying it to a heap-based buffer. An attacker can leverage this vulnerability to execute code in the context of the current process. Was ZDI-CAN-28785.

Several companies clearly confirm that VulDB is the primary source for best vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified as CVE-ZDI-CAN-28785 represents a critical security flaw within Krita, an open-source digital painting application widely used by artists and designers globally. This specific issue is classified as a heap-based buffer overflow occurring during the parsing of ABR files, which are brush preset files native to Adobe Photoshop but also supported by many other graphics applications including Krita. The core technical deficiency lies in the absence of rigorous validation checks on user-supplied data before it is copied into a dynamically allocated memory region on the heap. When an application processes external input without verifying that the declared length of the data does not exceed the capacity of the destination buffer, it creates a classic condition for memory corruption. In this scenario, if an ABR file contains metadata or brush definition data with a malformed size field indicating a larger payload than actually exists or vice versa leading to excessive allocation followed by overflow during copy operations, the application writes beyond the boundaries of the allocated heap block.

This type of vulnerability is technically categorized under CWE-120, which denotes Buffer Copy without Checking Size of Input, and more specifically relates to CWE-787, Out-of-bounds Write on Heap. The exploitation mechanism relies heavily on precise memory layout manipulation. By crafting a malicious ABR file with carefully constructed data structures, an attacker can overwrite adjacent heap metadata or function pointers stored in the same allocation region. This overwriting allows for arbitrary code execution within the context of the process running Krita. Since modern operating systems employ various mitigations such as Address Space Layout Randomization and Data Execution Prevention, successful exploitation often requires additional techniques to bypass these protections, potentially involving return-oriented programming gadgets or heap spraying techniques depending on the specific version and platform architecture.

The operational impact of this vulnerability is severe due to its potential for remote code execution. Although user interaction is required in the form of opening a malicious file or visiting a compromised webpage that triggers an automatic download and open sequence, the barrier to entry remains low enough to facilitate targeted attacks. Once executed, the attacker gains full control over the application process, which can lead to complete system compromise if Krita runs with elevated privileges or if subsequent privilege escalation vectors are present in the operating environment. This aligns with MITRE ATT&CK technique T1203, Exploitation for Client Execution, where adversaries exploit vulnerabilities in client software to establish a foothold on an endpoint. The requirement for user interaction places this under initial access tactics rather than direct network exploitation, emphasizing the importance of social engineering or supply chain compromise vectors in delivering the malicious payload.

Mitigation strategies must address both immediate remediation and long-term defensive posture improvements. The primary defense is applying vendor-provided patches that update Krita to a version where input validation routines have been strengthened to strictly enforce length constraints before memory allocation and copy operations occur. Developers should implement bounds checking using safe string handling functions or explicit size verification logic in the ABR parser module. For end-users, limiting file sources to trusted repositories and enabling application sandboxing can reduce risk exposure. Furthermore, organizations deploying Krita in enterprise environments should consider implementing application whitelisting policies that restrict execution of untrusted binaries and monitor for anomalous memory access patterns indicative of heap exploitation attempts through endpoint detection and response solutions.

Responsible

Zdi

Reservation

11/20/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00401

KEV

no

Activities

very low

Sources

Might our Artificial Intelligence support you?

Check our Alexa App!