Skip to main content

libheif CVE-2026-84448

| EUVDEUVD-2026-83015 MEDIUM
Out-of-bounds Read (CWE-125)
2026-09-18 GitHub_M
4.0
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach app that builds region metadata via writer API
  2. Delivery
    Supply geometry with undersized mask_data_len
  3. Exploit
    heif_region_item_add stores buffer unchecked
  4. Execution
    heif_region_get_mask_image reads past heap allocation
  5. Impact
    Adjacent heap bytes copied into mask image / crash

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

Exploitation requires an application that constructs region metadata through libheif's WRITER API and calls heif_region_item_add_region_inline_mask_data() with a mask_data_len that does not equal (width*height+7)/8, followed by a heif_region_get_mask_image() render. The file-parsing/decode path is explicitly NOT vulnerable because it validates the canonical mask size, so simply opening a malicious HEIF/AVIF file does not trigger it. Realistic risk is therefore limited to programs that let attacker-influenced geometry and mask buffers disagree while building inline-mask regions; affected versions are libheif prior to 1.23.2, and the vector is local (AV:L) with high attack complexity (AC:H).

Impact

This is a genuine but low-priority memory-safety issue, not a high-CVSS emergency. The vendor CVSS 3.1 base score is 4.0 (AV:L/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:L), and the signals are internally consistent with a narrow, hard-to-reach bug: local vector, high attack complexity, limited confidentiality impact (partial heap disclosure) and low availability impact (crash). No EPSS score, no CISA KEV listing, and no public exploit are present in the intelligence - the only 'PoC' is a vendor regression test in tests/region.cc that demonstrates the OOB read, which is not a weaponized exploit. The single most important limiting factor, confirmed by both the description and the commit diff, is that ONLY the writer/encoder path is vulnerable: heif_region_item_add_region_inline_mask_data() trusts caller-supplied mask_data_len, whereas the file-PARSING path (RegionGeometry_InlineMask::parse) already validates the canonical mask size and is explicitly NOT affected. That inverts the usual libheif threat model - a malicious HEIF/AVIF file does NOT trigger this; instead an application must itself call the region-writer API with attacker-influenced geometry and an undersized mask buffer. There is no conflict between the CVSS vector and the description; both point to a local, application-integration-dependent issue rather than remote drive-by exploitation.

Exploit ScenarioDerived

An application uses libheif's writer API to attach inline-mask region metadata, deriving mask geometry (width/height) and the mask buffer from separate, partly attacker-controlled inputs. The attacker supplies a mask_data_len smaller than ceil(width*height/8), so a later heif_region_get_mask_image() call reads past the undersized heap allocation and copies adjacent heap bytes into the returned monochrome mask, disclosing heap contents or crashing the process. No public weaponized exploit exists; only a vendor regression test demonstrates the out-of-bounds read, and the CVSS AV:L/AC:H rating reflects that this requires a specific writer-API integration rather than remote file parsing.

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

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

Alert me

AnalysisAIv1 – Sep 18, 2026

Heap out-of-bounds read in libheif prior to 1.23.2 lets an application that builds inline-mask region metadata through the library's writer API leak adjacent heap memory or crash. Specifically, heif_region_item_add_region_inline_mask_data() stored a caller-supplied mask buffer without verifying that mask_data_len equals ceil(width*height/8); a later heif_region_get_mask_image() render derives the number of bytes to read from the region geometry, so an undersized buffer causes the reader to copy bytes past the end of the allocation into the returned monochrome mask image. The file-parsing/decode path validates the canonical mask size and is explicitly not vulnerable, so merely opening a crafted HEIF/AVIF file does not trigger the bug; exploitation requires a local program in which attacker-influenced geometry and mask data disagree, consistent with the assessed vector AV:L/AC:H/PR:N/UI:N (CVSS 4.0). There is no confirmed active exploitation (no CISA KEV listing), and no public exploit code was identified at time of analysis; the issue is a genuine but low-priority memory-safety defect rather than an emergency, and version 1.23.2 fixes it.

RemediationAI

Vendor-released patch: libheif 1.23.2 - upgrade to that version (or later) from https://github.com/strukturag/libheif/releases/tag/v1.23.2, which incorporates commit 646d85fbf5bd18fc3cdc516e915e59072de2d510 and enforces mask_data_len == (width*height+7)/8, rejects null and zero-dimension masks, and adds a bounds check in the reader; the upstream advisory is https://github.com/strukturag/libheif/security/advisories/GHSA-p58j-h3vm-3fp5. If immediate upgrade is not possible, the practical compensating control is to change calling code rather than the library: ensure every call to heif_region_item_add_region_inline_mask_data() passes a mask buffer of exactly ceil(width*height/8) bytes and non-zero width/height, deriving that size from the same geometry used for the region, and reject or clamp attacker-influenced inputs before they reach the API - the trade-off is that mismatched-but-harmless oversized buffers that previously worked silently will now need to be trimmed by the caller, and any input path where geometry and mask data can disagree must be removed or validated. As a secondary containment measure, applications that render inline-mask regions from untrusted geometry should validate dimensions and buffer lengths at their own boundary before calling the writer API, since patched versions will reject such mismatches with heif_error_Invalid_input rather than accepting them. No patch is required for pure decode/parse workloads, which were never vulnerable; note there is no vendor-released fix for versions below 1.23.2 other than the upgrade.

Affected VersionsENISA

libheif < 1.23.2

Affected Packages

euvd libheif fix: 1.23.2

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

libheif is a HEIF and AVIF decoder/encoder whose region API (libheif/api/libheif/heif_regions.cc) supports inline-mask regions, where a bitmask with one bit per pixel is stored as ceil(width*height/8) bytes with no inter-row padding beyond the final byte. The root cause is CWE-125 (Out-of-Bounds Read): the writer-side function heif_region_item_add_region_inline_mask_data() accepted mask_data_len verbatim and resized the internal region->mask_data buffer to that value, instead of recomputing the canonical byte count from the supplied width and height as RegionGeometry_InlineMask::parse() does on the file-parsing path. Because heif_region_get_mask_image()/heif_region_get_inline_mask_image() compute the read length from geometry, a buffer shorter than the canonical size causes reads past the heap allocation at mask_data[mask_byte], and those adjacent bytes are written into the output mask image (C:L), with a possible crash of the host application (A:L). The upstream fix adds null-pointer and zero-dimension checks, rejects any mask_data_len that does not equal (width*height+7)/8 with heif_error_Invalid_input/heif_suberror_Invalid_region_data, guards against size overflow, and adds defence-in-depth bounds checking (mask_byte < mask_data_len) in the reader; a regression test covers a 64x3 region requiring 24 bytes of mask data. The affected CPE is strukturag:libheif (all versions prior to 1.23.2).

Know when Libheif 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

Vendor (GitHub_M) PRIMARY 4.0 MEDIUM
AV:L/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:L
vuln.today AI 4.0 MEDIUM

Only reachable via the local writer-API integration with mismatched geometry/mask buffer (AV:L, AC:H); no auth needed (PR:N); partial heap disclosure (C:L) and possible crash (A:L).

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Sep 18, 2026 - 17:17 EUVD
CVE Published
Sep 18, 2026 - 15:53 cve.org
MEDIUM 4.0

DescriptionCVE.org

libheif is a HEIF and AVIF file format decoder and encoder. Prior to 1.23.2, the public heif_region_item_add_region_inline_mask_data() function in libheif/api/libheif/heif_regions.cc accepts mask_data_len without verifying that it equals the byte count required by width and height. A later heif_region_get_mask_image() call derives the read length from the region geometry, so an undersized stored buffer causes heif_region_get_inline_mask_image() to read beyond the heap allocation and copy adjacent bytes into the returned monochrome mask image. This can disclose heap data or crash an application that constructs region metadata through the writer API, while the file-parsing path is not affected because it validates the canonical mask size. This issue is fixed in version 1.23.2.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
High
libheif is the standard HEIF/AVIF decoder in GNOME, KDE, ImageMagick, libvips
Data Quality
7 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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
High

Priority Score

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

CVE-2023-49464 HIGH POC
8.8 Dec 07

libheif v1.17.5 was discovered to contain a segmentation violation via the function UncompressedImageCodec::get_luma_bit

CVE-2023-49463 HIGH POC
8.8 Dec 07

libheif v1.17.5 was discovered to contain a segmentation violation via the function find_exif_tag at /libheif/exif.cc. R

CVE-2023-49462 HIGH POC
8.8 Dec 07

libheif v1.17.5 was discovered to contain a segmentation violation via the component /libheif/exif.cc. Rated high severi

CVE-2023-49460 HIGH POC
8.8 Dec 07

libheif v1.17.5 was discovered to contain a segmentation violation via the function UncompressedImageCodec::decode_uncom

CVE-2019-11471 HIGH POC
8.8 Apr 23

libheif 1.4.0 has a use-after-free in heif::HeifContext::Image::set_alpha_channel in heif_context.h because heif_context

CVE-2024-41311 HIGH POC
8.1 Oct 15

In Libheif 1.17.6, insufficient checks in ImageOverlay::parse() decoding a heif file containing an overlay image with fo

CVE-2024-25269 HIGH POC
7.5 Mar 05

libheif <= 1.17.6 contains a memory leak in the function JpegEncoder::Encode. Rated high severity (CVSS 7.5), this vulne

CVE-2025-68431 HIGH POC
7.1

Out-of-bounds read in libheif's HEIF/HEIC overlay processing can disclose limited memory contents and crash affected app

CVE-2023-29659 MEDIUM POC
6.5 May 05

A Segmentation fault caused by a floating point exception exists in libheif 1.15.1 using crafted heif images via the hei

CVE-2025-29482 MEDIUM POC
6.2 Apr 07

Buffer Overflow vulnerability in libheif 1.19.7 allows a local attacker to execute arbitrary code via the SAO (Sample Ad

CVE-2026-84383 CRITICAL
9.8 Sep 04

Heap-based buffer overflow in libheif before 1.23.2 allows remote attackers to corrupt memory and potentially achieve co

CVE-2026-32740 HIGH
8.8 May 19

Heap buffer overflow write in libheif (versions ≤ 1.21.2) lets a crafted HEIF/AVIF file write 64 bytes of attacker-contr

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
openSUSE Tumbleweed Fixed
SUSE Linux Enterprise Module for Desktop Applications 15 SP7 Affected
SUSE Linux Enterprise Server 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Server for SAP Applications 15 SP7 Affected

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