Skip to main content

Sdl Image CVE-2026-35444

| EUVDEUVD-2026-19527 MEDIUM
Out-of-bounds Read (CWE-125)
2026-04-06 security-advisories@github.com
6.1
CVSS 3.1 · NVD
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Craft malicious XCF file with undersized colormap
  2. Delivery
    Load file via SDL_image library
  3. Exploit
    Decode tile data with out-of-range pixel indices
  4. Execution
    Read 762 bytes past colormap allocation
  5. Impact
    Leak 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

SDL_image < 996bf12888925932daace576e09c3053410896f8

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

NVD PRIMARY 6.1 MEDIUM
AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:L
SUSE 7.1 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:L

Primary rating from NVD.

CVSS VectorNVD

Attack Vector
Local
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
None
Availability
Low

Lifecycle Timeline

5
Severity Changed
Jul 24, 2026 - 21:22 NVD
HIGH MEDIUM
CVSS changed
Jul 24, 2026 - 21:22 NVD
7.1 (HIGH) 6.1 (MEDIUM)
Analysis Updated
Apr 16, 2026 - 06:05 EUVD-patch-fix
executive summary
Patch available
Apr 16, 2026 - 05:29 EUVD
996bf12888925932daace576e09c3053410896f8
CVE Published
Apr 06, 2026 - 22:16 nvd
HIGH 7.1

DescriptionNVD

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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.0%
Top 98% exploitable
Data Quality
8 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub VulDB

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
Medium
Technical Impact
Partial

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +30
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

Vendor StatusVendor

SUSE

Severity: High
Product Status
openSUSE Tumbleweed Fixed

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy