Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious XCF file with undersized colormap
-
DeliveryLoad file via SDL_image library
-
ExploitDecode tile data with out-of-range pixel indices
-
ExecutionRead 762 bytes past colormap allocation
-
ImpactLeak heap memory into output surface
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Victim must open a crafted .xcf image file in an application using SDL_image library (any version containing do_layer_surface() function in src/IMG_xcf.c). No authentication required. Affects indexed color XCF files with undersized colormaps and out-of-range pixel indices. |
| Impact | The CVSS v3.1 score of 7.1 (High) reflects network-based attack vector with low complexity and no authentication requirements, though user interaction is required (AV:N/AC:L/PR:N/UI:R). The impact profile shows high confidentiality impact but no integrity impact and low availability impact (C:H/I:N/A:L), consistent with an information disclosure vulnerability. Real-world risk is moderate to significant because SDL_image is embedded in numerous applications including games, image viewers, and content management systems where users routinely open untrusted image files. The heap memory disclosure of up to 762 bytes could leak cryptographic keys, session tokens, or other sensitive data depending on allocator state. However, successful exploitation requires social engineering to convince users to open crafted XCF files, and the leaked data appears in rendered output rather than being directly exfiltrated, reducing immediate severity. No public exploit identified at time of analysis and no CISA KEV listing indicates this is not yet actively exploited in the wild. The fixed commit (996bf12888925932daace576e09c3053410896f8) is available, suggesting patches should be readily deployable. Attack automation is possible but requires targeted file distribution. Technical impact is limited to information disclosure rather than code execution, positioning this as a priority for applications processing untrusted XCF files but not requiring emergency response for most deployments. |
| Exploit ScenarioDerived | An attacker crafts a malicious XCF file with a deliberately small colormap (e.g., 16 entries) but embeds tile data containing pixel index values of 250 or higher. When a victim opens this file in any application using vulnerable SDL_image (such as a game level editor, image viewer, or content creation tool), the do_layer_surface() function reads 762 bytes beyond the colormap heap allocation. These out-of-bounds bytes, which may contain cryptographic material, authentication tokens, or other sensitive data from adjacent heap objects, are copied into the output surface pixel buffer. The attacker retrieves the rendered image through normal application workflows (saved files, screenshots, or network transmission in collaborative tools) and extracts the leaked heap data from the pixel values. No public exploit identified at time of analysis, but the attack requires only file format manipulation skills and standard image editing tools to construct the malicious payload. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Apr 06, 2026
Heap out-of-bounds read in SDL_image library's XCF format parser allows remote information disclosure when processing malicious GIMP files. Attackers can craft .xcf files with undersized colormaps and invalid pixel indices to leak up to 762 bytes of heap memory into rendered image data, potentially exposing sensitive process memory. The vulnerability affects both indexed color code paths (1-bit and 2-bit per pixel). No public exploit identified at time of analysis, but EPSS and exploitation likelihood are notable given the library's widespread use in gaming and multimedia applications requiring minimal user interaction (opening a file).
RemediationAI
Upstream fix available via commit 996bf12888925932daace576e09c3053410896f8 in the libsdl-org/SDL_image repository; released patched version not independently confirmed from available data. Organizations should monitor the SDL_image release page for tagged versions incorporating this commit and upgrade immediately upon availability. Until a released version is confirmed, development builds can integrate the fix commit directly from source. As an interim mitigation, applications can disable XCF format support if not operationally required by removing or not registering the XCF loader module, though this may break functionality for users expecting GIMP file compatibility. Input validation layers should restrict accepted image formats to trusted types where feasible. Security-conscious deployments should sandbox image processing operations to limit heap disclosure impact. Consult the official advisory at https://github.com/libsdl-org/SDL_image/security/advisories/GHSA-gq8w-x74c-h6p7 for vendor-specific guidance and version recommendations as they become available.
Affected VersionsENISA
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
SDL_image is a widely-used auxiliary library for Simple DirectMedia Layer (SDL) that handles loading various image formats including GIMP's native XCF format. The vulnerability exists in the do_layer_surface() function within src/IMG_xcf.c, specifically in the IMAGE_INDEXED rendering path. When decoding XCF tile data, the code extracts pixel index values and uses them to look up colors in a colormap structure without boundary validation. The colormap size is defined by the cm_num field, but pixel indices from untrusted tile data are applied directly as array offsets. This represents a classic CWE-125 (Out-of-bounds Read) vulnerability. Both bpp=1 and bpp=2 code paths trust pixel indices implicitly, allowing indices >= cm_num to read beyond the allocated colormap buffer. The vulnerable code path is triggered during normal image loading operations when processing indexed-color XCF layers, making it reachable through standard library APIs without requiring special modes or configurations.
Know when Sdl Image 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:L/PR:N/UI:R/S:U/C:H/I:N/A:L
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:L
Primary rating from NVD.
CVSS VectorNVD
Lifecycle Timeline
5DescriptionNVD
SDL_image is a library to load images of various formats as SDL surfaces. In do_layer_surface() in src/IMG_xcf.c, pixel index values from decoded XCF tile data are used directly as colormap indices without validating them against the colormap size (cm_num). A crafted .xcf file with a small colormap and out-of-range pixel indices causes heap out-of-bounds reads of up to 762 bytes past the colormap allocation. Both IMAGE_INDEXED code paths are affected (bpp=1 and bpp=2). The leaked heap bytes are written into the output surface pixel data, making them potentially observable in the rendered image. This vulnerability is fixed with commit 996bf12888925932daace576e09c3053410896f8.
Executive ViewAI
SDL_image library versions prior to the patch release contain a heap memory disclosure vulnerability triggered by malicious GIMP (.xcf) files, potentially exposing up to 762 bytes of sensitive process memory when users open crafted files. This affects any application using SDL_image for image processing, particularly gaming engines and multimedia software where end-users routinely open untrusted files, creating a direct path for attackers to extract confidential data without user action beyond standard file operations.
Apply vendor patch. If immediate patching is not feasible, restrict file handling to trusted sources only and implement network-level controls to block .xcf file downloads where possible, though neither measure fully mitigates the vulnerability.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
An exploitable code execution vulnerability exists in the XCF image rendering functionality of SDL2_image-2.0.3. Rated h
An exploitable code execution vulnerability exists in the XCF image rendering functionality of Simple DirectMedia Layer
An exploitable information vulnerability exists in the XCF image rendering functionality of Simple DirectMedia Layer SDL
An exploitable information disclosure vulnerability exists in the PCX image rendering functionality of Simple DirectMedi
An exploitable buffer overflow vulnerability exists in the XCF property handling functionality of SDL_image 2.0.1. Rated
A stack out-of-bounds read in SDL_image's ILBM/LBM loader (IMG_LoadLBM_IO in src/IMG_lbm.c) lets a crafted image with th
Same weakness CWE-125 – Out-of-bounds Read
View allSame technique Buffer Overflow
View allVendor StatusVendor
SUSE
Severity: High| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
EUVD-2026-19527
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB