Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft oversized malicious image file
-
DeliveryVictim opens file and runs Hot filter
-
Exploit32-bit size arithmetic overflows, undersizing heap buffer
-
ExecutionPixel write exceeds allocation, corrupting heap
-
ImpactCrash or arbitrary code execution as user
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, buffer size validation
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires a victim to open an attacker-supplied, very large image in GIMP and specifically invoke the 'Hot' color filter plug-in; the overflow only triggers when the image's width*height (and related) arithmetic overflows 32-bit integers, so only images with extremely large dimensions reach the vulnerable path. Limiting factors per the CVSS vector: local access (AV:L) with no remote network reachability, mandatory user interaction (UI:R) to load the file and run the filter, no privileges required (PR:N) but execution is confined to the running user's context, and high attack complexity (AC:H) because the attacker must construct dimensions that reliably overflow the allocation arithmetic. These constraints make mass or automated exploitation impractical; it is a targeted, social-engineering-dependent client-side attack. |
| Impact | This is a genuinely moderate-risk issue, not a high-priority emergency. The CVSS 3.1 base score of 6.3 (AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:H) accurately reflects a constrained attack surface: the attacker needs local delivery of a file, the victim must actively load that file and invoke the Hot color filter, and the overflow condition only arises for 'very large images' where 32-bit width*height arithmetic overflows - hence the legitimate AC:H rating. No EPSS score was provided in the input, and KEV status is not indicated (treat as not listed). No proof-of-concept was referenced, so there is no public exploit identified at time of analysis. The impact is limited to integrity and availability (heap corruption leading to crash or potential code execution in the context of the desktop user running GIMP); confidentiality is rated N and there is no SSVC data supplied. The signals are internally consistent - a client-side, user-interaction-dependent memory-corruption bug in a desktop image editor - so there is no contradiction to flag between vector and description. The one caveat worth stating: a heap-based buffer overflow could in principle enable arbitrary code execution, which some analysts would score with C:H rather than C:N, so the confidentiality impact is arguably understated, but the provided vector's C:N is defensible if exploitation yields only corruption/crash. |
| Exploit ScenarioDerived | An attacker distributes a maliciously crafted image file with extremely large dimensions (e.g. via email, a shared project, or a download) and social-engineers a GIMP user into opening it and applying the Hot color filter. The integer-overflowed allocation produces an undersized heap buffer while the filter's pixel path writes using the true image size, corrupting heap memory and potentially leading to code execution in the user's context. No public proof-of-concept exploit was identified in the provided data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 07, 2026
Heap-based buffer overflow in GIMP's 'Hot' color filter plug-in allows a crafted, extremely large image to corrupt heap memory when the filter is invoked, giving an attacker the ability to crash the plug-in and potentially achieve code execution within the running user's session (CWE-119). The flaw is reachable only locally and requires the victim to open an attacker-supplied image with dimensions so large that the width * height allocation arithmetic overflows 32-bit integers, then actively run the Hot filter on it - hence the assessed vector AV:L/AC:H/PR:N/UI:R with high integrity and availability impact but no confidentiality impact. There is no public exploit identified at time of analysis, no CISA KEV listing, and no EPSS score provided, so this is a targeted, social-engineering-dependent client-side issue rather than an automatable, mass-exploitation threat. Red Hat hosts the primary advisory (access.redhat.com/security/cve/CVE-2026-106067) with tracking in Bugzilla 2547461, and GIMP packages across Red Hat Enterprise Linux 6 through 10 are enumerated as affected via CPE.
RemediationAI
The provided intelligence does not include a fixed version or a patched-release reference for the GIMP Hot filter plug-in, so no vendor-released patch can be confirmed from the supplied data; Monitor https://access.redhat.com/security/cve/CVE-2026-106067 and https://bugzilla.redhat.com/show_bug.cgi?id=2547461 for Red Hat errata and apply the updated gimp package for RHEL 6-10 as soon as it is published. Until then, the most effective compensating control is to avoid opening image files from untrusted sources in GIMP at all, and specifically never to run the Hot color filter on such files - this eliminates the required user interaction but is a workflow restriction with real productivity cost. Where untrusted images must be handled, process them in a sandbox or container with no access to the user's home directory, credentials or network, so that any code execution is confined to the disposable environment; the trade-off is reduced file access and some rendering/plug-in friction. Administrators can also enforce a maximum image dimension policy (rejecting images whose width or height approaches the 32-bit multiplication overflow threshold) through pre-processing or ingestion tooling, though this risks blocking legitimate very-high-resolution assets - such as panoramas, satellite imagery or scanned artwork - that are exactly the inputs the filter is most likely to encounter. Because exploitation is local and interaction-driven (AV:L, UI:R, PR:N, AC:H), perimeter controls such as network filtering do not apply; the practical mitigations are user awareness about unsolicited image files and least-privilege execution of the GIMP process.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
GIMP is a modular image editor whose filters (plug-ins) run as separate processes against a shared image buffer, and the Hot color filter is one such plug-in. The root cause is integer overflow feeding a heap allocation: for images with very large dimensions, the code computes the pixel buffer size using 32-bit width * height (and related) arithmetic, which wraps and produces a much smaller allocation than required. The filter's pixel access path, however, iterates using the true (untruncated) image dimensions, so writes walk past the end of the undersized heap buffer - this is the classic CWE-119 improper restriction of operations within the bounds of a memory buffer, manifesting specifically as a heap-based overflow. Because only images whose dimensions overflow 32-bit multiplication reach the vulnerable path, an attacker must deliberately choose dimensions that reliably wrap the allocation arithmetic while still being accepted by GIMP, which is why the assessment rates attack complexity as high (AC:H). The CPE data identifies the affected distribution channel as Red Hat Enterprise Linux 6, 7, 8, 9 and 10, meaning the vulnerable GIMP plug-in ships in those Red Hat product lines and inherits Red Hat's errata cadence rather than an upstream-only fix.
Know when Gimp 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:L/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:H
Victim must open a crafted file locally (AV:L, UI:R); AC:H because only very large images overflow the 32-bit size arithmetic; PR:N; heap corruption yields I:H/A:H, C:N absent confirmed disclosure.
Primary rating from Vendor (redhat).
CVSS VectorVendor: redhat
DescriptionCVE.org
A heap-based buffer overflow was found in GIMP’s Hot color filter plug-in. For very large images, a pixel buffer is allocated using overflowing 32-bit width * height (and related) arithmetic while the filter’s pixel access path uses the true image size, after integer overflow in the allocation size
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.
Affected Products (CPE)CVE.org
Buffer overflow in the readstr_upto function in plug-ins/script-fu/tinyscheme/scheme.c in GIMP 2.6.12 and earlier, and p
Multiple stack-based buffer overflows in file-xwd.c in the X Window Dump (XWD) plug-in in GIMP 2.8.2 allow remote attack
In GIMP 2.8.22, there is a heap-based buffer overflow in read_channel_data in plug-ins/common/file-psp.c. Rated high sev
fits-io.c in GIMP before 2.8.1 allows remote attackers to cause a denial of service (NULL pointer dereference and applic
An issue in gimp_layer_invalidate_boundary of GNOME GIMP 2.10.30 allows attackers to trigger an unhandled exception via
GIMP 2.10.30 and 2.99.10 are vulnerable to Buffer Overflow. Rated medium severity (CVSS 5.5), this vulnerability is no a
GIMP through 2.10.2 makes g_get_tmp_dir calls to establish temporary filenames, which may result in a filename that alre
Critical remote code execution vulnerability in GIMP's ICO file parser caused by an integer overflow (CWE-190) that lack
Remote code execution in GIMP 3.0.6 allows attackers to run arbitrary code by tricking a user into opening a malicious P
Remote code execution in GIMP 3.2.0-rc1 lets attackers run arbitrary code by tricking a user into opening a malicious IC
Use-after-free vulnerability in the xcf_load_image function in app/xcf/xcf-load.c in GIMP allows remote attackers to cau
Heap-based buffer overflow in GIMP's TIF file parser enables remote code execution when a user opens a crafted TIFF imag
EUVD-2026-94529
GHSA-3rg9-87vj-hg53
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB