Skip to main content

SAIL image library EUVDEUVD-2026-82408

| CVE-2026-54627 CRITICAL
Heap-based Buffer Overflow (CWE-122)
2026-09-17 security-advisories@github.com
9.8
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

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

  1. Access
    Craft PSD with Bitmap mode, depth 8
  2. Delivery
    Deliver file to SAIL-using application
  3. Exploit
    App calls sail_load_from_file/from_memory
  4. Execution
    Codec writes byte-per-pixel into 1-bit rows
  5. Persist
    Heap overflow past each row
  6. Impact
    Crash or potential code execution

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

Requires a target application that uses SAIL <=0.9.10 to decode an attacker-supplied PSD image through sail_load_from_file() or sail_load_from_memory(). The specific trigger is a PSD in Bitmap color mode with one channel and file depth == 8 (rather than the expected depth 1), which causes psd_private_sail_pixel_format() to select SAIL_PIXEL_FORMAT_BPP1_INDEXED while the loader writes 8-bit bytes per pixel. Limiting factors: the vulnerable app must actually process attacker-controlled PSD input (effectively user/content interaction), and the byte-per-pixel overflow's escalation to code execution depends on heap layout, making a reliable crash the most dependable outcome. No authentication is required against the library itself.

Impact

The vendor CVSS of 9.8 (AV:N/AC:L/PR:N/UI:N) overstates real-world risk. This is a file-parsing memory-corruption bug in an image-decoding library: exploitation requires the victim application to load an attacker-crafted PSD via sail_load_from_file()/sail_load_from_memory(), which realistically implies attacker-supplied-content interaction (UI:R), so the 'no user interaction' rating is questionable - verify with vendor. The vulnerability is confirmed and well-substantiated: the commit diff (f44a8b7) directly shows the mode/depth validation gap, so the root cause is not in doubt. However, no EPSS score, no CISA KEV listing, and no public exploit are present in the input, so there is no evidence of active exploitation - exploitation status is 'no public exploit identified.' The primitive itself is meaningful: one attacker-controlled byte written past each heap row is a strong corruption primitive, so C:H/I:H/A:H is defensible for the code-execution ceiling, but the description frames outcome primarily as 'memory corruption, a reliable crash, or potential code execution,' meaning a reliable crash (DoS) is the most certain impact and RCE is aspirational and heap-layout dependent. Net: a genuine high-severity library bug worth patching promptly, but the 9.8 with UI:N inflates the practical priority for most deployments.

Exploit ScenarioDerived

An attacker crafts a PSD file declaring Bitmap color mode with one channel but depth 8, then delivers it to a target that uses SAIL to decode images (e.g., a thumbnailer, upload processor, or desktop viewer). When the application calls sail_load_from_file() or sail_load_from_memory(), the codec allocates one-bit rows but writes one attacker-controlled byte per pixel, corrupting the heap beyond each row and causing a reliable crash or potentially code execution. No public exploit code is identified at time of analysis, though the fixing commit diff clearly reveals the mismatch.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 17, 2026

Heap-based buffer overflow in the SAIL image library's PSD decoder affects versions 0.9.10 and earlier, letting a crafted PSD file corrupt heap memory, reliably crash the host process, and potentially achieve code execution. Any application that passes attacker-controlled PSD data to sail_load_from_file() or sail_load_from_memory() is exposed; the CVSS vector carries PR:N (unauthenticated against the library), but practical exploitation still requires a victim to open or process a malicious image (UI:R), so the vendor's 9.8/UI:N rating overstates real-world risk. No public exploit code or confirmed active exploitation was identified at time of analysis, and the flaw is fixed in SAIL 1.0.0.

RemediationAI

Vendor-released patch: upgrade to SAIL 1.0.0, which is the version where the depth/mode validation was fixed (see https://github.com/HappySeaFox/sail/releases/tag/v1.0.0, commit f44a8b779a1fc527fc6bc5caa71a66a8ed940d50, and advisory GHSA-ccqf-rv86-h3wm); rebuild and redeploy any application statically or dynamically linked against SAIL 0.9.10 or earlier. If immediate upgrade is not possible, apply compensating controls with the understanding that they reduce, not eliminate, exposure: reject or quarantine PSD uploads and disable PSD decoding in image-processing endpoints entirely (side effect: loss of PSD support, which may break legitimate workflows); or pre-validate PSD headers before handing data to SAIL, rejecting any file whose color mode is Bitmap with one channel while declaring depth 8, since the mismatch is the trigger (side effect: requires a parsing shim in every consumer and must itself be robust against malformed/truncated files). Because the overflow's escalation to code execution depends on heap layout and reliable crash is the most dependable outcome, isolate the decoder in a sandboxed, low-privilege worker process (seccomp/AppArmor/container, no network or filesystem write access) and enable ASLR plus a hardened allocator to make successful corruption harder to exploit, accepting the added operational complexity and per-request process overhead.

Affected VersionsENISA

sail < 1.0.0

Affected Packages

euvd sail fix: 1.0.0

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

SAIL is a cross-platform C library for loading and saving images with animation, metadata, and ICC profile support, and the flaw lives in its Adobe Photoshop (PSD) codec. In src/sail-codecs/psd/helpers.c, psd_private_sail_pixel_format() resolved a PSD in Bitmap color mode with a single channel to SAIL_PIXEL_FORMAT_BPP1_INDEXED purely from the color mode, without checking the file's declared bit depth; meanwhile sail_codec_load_frame_v8_psd() in src/sail-codecs/psd/psd.c independently accepted depth 8 and wrote one attacker-controlled byte per pixel. The result is a mode/depth mismatch: heap rows sized for one bit per pixel receive eight-bit writes, producing a linear out-of-bounds write past each row (CWE-122, heap-based buffer overflow). The upstream fix commit f44a8b779a1fc527fc6bc5caa71a66a8ed940d50 both tightens the pixel-format resolver so the 1bpp indexed path requires depth 1 (and the 8bpp indexed path requires depth == 8) and moves pixel-format resolution earlier in sail_codec_load_seek_next_frame_v8_psd() so malformed depth/mode combinations are rejected before decoding begins. This defect is explicitly distinct from the previously addressed GHSA-rcqx-gc76-r9mv and GHSA-wcj8-hxxf-pq2c advisories.

Know when the next one hits your stack

  • 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

Vendor (github) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

File must be delivered to and loaded by the victim application, so UI:R rather than vendor's UI:N; heap write primitive supports C:H/I:H/A:H as the code-execution ceiling.

3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (github).

CVSS VectorVendor: github

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

Lifecycle Timeline

2
Patch available
Sep 17, 2026 - 21:19 EUVD
CVE Published
Sep 17, 2026 - 20:16 cve.org
CRITICAL 9.8

DescriptionCVE.org

SAIL is a cross-platform library for loading and saving images with support for animation, metadata, and ICC profiles. In 0.9.10 and earlier, psd_private_sail_pixel_format() in src/sail-codecs/psd/helpers.c resolves a one-channel PSD in Bitmap color mode to SAIL_PIXEL_FORMAT_BPP1_INDEXED without requiring the file depth to be one, so the pixel buffer uses one-bit rows while sail_codec_load_frame_v8_psd() in src/sail-codecs/psd/psd.c accepts depth == 8 and writes one attacker-controlled byte per pixel. Loading a crafted PSD through sail_load_from_file() or sail_load_from_memory() therefore writes beyond each heap row, causing memory corruption, a reliable crash, or potential code execution. This mode/depth mismatch is distinct from GHSA-rcqx-gc76-r9mv and GHSA-wcj8-hxxf-pq2c. This issue is fixed in version 1.0.0.

Technical POC Analysis

Heap-based buffer overflow, CWE-122 (advisory also lists CWE-787).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

A critical memory-corruption flaw in the SAIL image library (versions 0.9.10 and earlier) means any product, service, or internal tool that decodes PSD files with this library can be crashed or potentially taken over by a single malformed image, exposing customers and staff who routinely open or upload design files. Because SAIL is typically embedded inside other applications rather than installed on its own, leadership should treat this as a supply-chain exposure: the risk sits with every product team that has shipped or depends on the vulnerable library, and remediation requires coordinated upgrades rather than a single endpoint fix. No public exploit code or confirmed active exploitation was identified at time of analysis, so the immediate priority is inventory and staged upgrade rather than emergency containment.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 62% exploitable
Prevalence
Low
niche open-source cross-platform image library, limited production footprint
Data Quality
6 sources
Confidence: High

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Total

Priority Score

49
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +49
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.

A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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