Skip to main content

OpenImageIO EUVDEUVD-2026-83134

| CVE-2026-67549 HIGH
Heap-based Buffer Overflow (CWE-122)
2026-09-18 GitHub_M
7.6
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious 1-bit CMYK TIFF
  2. Delivery
    Deliver file to victim pipeline
  3. Exploit
    Application opens image via OpenImageIO
  4. Execution
    bit_convert writes 8-bit into uint1 buffer
  5. Persist
    Heap out-of-bounds write corrupts memory
  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

Exploitation requires the target application to read a crafted TIFF with the specific combination of PHOTOMETRIC_SEPARATED (CMYK, PhotometricInterpretation 5), 1 bit per sample (BitsPerSample 1), and contiguous/interleaved planar configuration (planarconfig contig), which causes OpenImageIO to expose a native uint1 ImageSpec and allocate a bit-packed buffer before bit_convert() overflows it. Exploitation is LIMITED by the need for user or application interaction (UI:R) - a victim must open or process the malicious image through software linked against OpenImageIO prior to 3.1.16.0; it is not a self-propagating or no-interaction remote flaw. It affects default parsing behavior for this TIFF variant (no special OIIO configuration is required), but only that narrow CMYK/1-bit/contiguous code path is vulnerable.

Impact

This is a heap out-of-bounds write (CWE-122) in OpenImageIO's TIFF reader, triggered when a crafted 1-bit contiguous CMYK TIFF is parsed: the ImageSpec is exposed as native uint1 (bit-packed buffer) but TIFFInput::bit_convert() writes one expanded 8-bit byte per value into that smaller allocation. The vendor CVSS 7.6 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:H) reflects network delivery of a malicious file but requires user/application interaction (UI:R) to open or process the image. No EPSS score, no CISA KEV listing, and no public exploit are present in the supplied data, so exploitation status is 'no public exploit identified at time of analysis' - this is not a confirmed in-the-wild threat. The signal set is internally consistent: AV:N reflects that images arrive over the network, but real exploitation depends on a host application feeding the file to OIIO. The A:H is well supported (heap corruption reliably crashes the parser); the C:L/I:L are conservative given that a controlled heap OOB write can, in principle, escalate toward code execution, though the vendor did not rate it as full RCE. Priority is moderate: the flaw is source-confirmed by the vendor advisory, PR, and fixing commit, but the lack of active-exploitation and POC signals plus the UI:R requirement keeps real-world urgency below that of an unauthenticated no-interaction RCE. Patch to 3.1.16.0 is the clear action.

Exploit ScenarioDerived

An attacker crafts a malformed 1-bit contiguous CMYK TIFF and delivers it to a victim who opens or processes it through an application built on OpenImageIO (a VFX/render pipeline, asset ingest service, or thumbnailer). When TIFFInput reads the scanline, bit_convert() writes expanded 8-bit output into an undersized bit-packed uint1 buffer, corrupting the heap and crashing or potentially enabling further exploitation. No public POC is identified, but a crash-reproducer TIFF (crash-cmyk-1bit.tif) was added to the project's test suite in the fix.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% 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-based out-of-bounds write in OpenImageIO before 3.1.16.0 lets remote attackers corrupt memory whenever an application linked against the library reads a crafted 1-bit contiguous CMYK TIFF, a condition that maps to CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:H (7.6). The flaw is reachable unauthenticated from the network perspective of the file, but exploitation is limited by the requirement that a victim open or process the malicious image (UI:R), and only that narrow PhotometricInterpretation 5 / BitsPerSample 1 / planarconfig contig code path is affected. Vendor-released patch: 3.1.16.0; no public exploit identified at time of analysis, though the upstream fix commit ships a regression test using a crafted sample (crash-cmyk-1bit.tif) that documents the exact triggering structure.

RemediationAI

Upgrade to OpenImageIO 3.1.16.0 or later; that release contains the vendor-released patch (Vendor-released patch: 3.1.16.0) and corresponds to upstream commit 6e9b86ee4cce8fd7bed6cfb101a266d8f8a296d4 via pull request #5296, with the advisory at https://github.com/AcademySoftwareFoundation/OpenImageIO/security/advisories/GHSA-3wxw-rqhw-j2w4. Rebuild every application and container image that links OpenImageIO, since the vulnerable code lives in the library rather than the consuming tool, and note that statically linked builds must be recompiled rather than relinked. If immediate upgrade is not possible, add an ingestion-side filter that rejects or quarantines TIFFs presenting PhotometricInterpretation 5 together with BitsPerSample 1 and PlanarConfiguration 1 before they reach OpenImageIO; the trade-off is that legitimate 1-bit CMYK separations are rare, so the functional impact on normal VFX pipelines should be small, but any TIFF with those tags will be blocked even if benign. Additional compensating measures include running image conversion in a sandboxed or memory-isolated process so that a heap corruption cannot escalate to code execution in the parent pipeline, and using hardened allocators (for example glibc malloc hardening or a guarded allocator such as Electric Fence/ASan in CI) to convert silent corruption into a loud crash; these reduce blast radius but do not fix the underlying out-of-bounds write, so they are stopgaps only.

Affected VersionsENISA

OpenImageIO < 3.1.16.0

Affected Packages

euvd openimageio fix: 3.1.16.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

OpenImageIO is a VFX/animation-oriented image I/O library whose tiff.imageio plugin (src/tiff.imageio/tiffinput.cpp) wraps libtiff. For a TIFF declared PHOTOMETRIC_SEPARATED (CMYK, PhotometricInterpretation 5) with oiio:BitsPerSample 1 and contour/contig planar configuration, the reader exposes a native uint1 ImageSpec, so the caller's contract is a bit-packed destination buffer sized for one bit per sample. When read_native_scanline_locked() decides whether to convert into a private scratch buffer, the pre-3.1.16.0 logic keyed only on m_separate; because the raw-color selection path did not set m_separate for this CMYK variant, bit_convert() was invoked against the caller's buffer while configured for 8-bit output, writing one full expanded byte per sample into an allocation sized for bits. That size mismatch is a classic CWE-122 heap buffer overflow: writes past the end of the bit-packed allocation corrupt adjacent heap metadata and neighboring objects. The upstream fix introduces use_scratch_dest = m_separate || (m_photometric == PHOTOMETRIC_SEPARATED && !m_raw_color) and substitutes it at the three call sites in read_native_scanline_locked(), forcing the expanded conversion into a suitably sized scratch buffer regardless of m_separate. The added test references (out-libtiff403/409/410/430) confirm the trigger is a 73x43, 3-channel, uint1 CMYK contig TIFF with RowsPerStrip 28 and no compression.

Know when Openimageio 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 7.6 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:H
vuln.today AI 7.6 HIGH

Malicious file arrives over the network but a user/app must open it (UI:R); heap OOB write reliably crashes the parser (A:H) with limited confidentiality/integrity impact as vendor-rated.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Sep 18, 2026 - 17:17 EUVD
CVE Published
Sep 18, 2026 - 15:49 cve.org
HIGH 7.6

DescriptionCVE.org

OpenImageIO is a toolset for reading, writing, and manipulating image files of any image file format relevant to VFX / animation. Prior to 3.1.16.0, A crafted 1-bit contiguous cmyk tiff is exposed through a native uint1 imagespec, so callers allocate a bit-packed buffer. tiffinput::read_native_scanline_locked() nevertheless invokes tiffinput::bit_convert() with 8-bit output and writes one expanded byte per value into that smaller buffer, resulting in a heap out-of-bounds write and memory corruption. The affected implementation is identified by src/tiff.imageio/tiffinput.cpp, TIFFInput::bit_convert(), TIFFInput::read_native_scanline_locked(), PHOTOMETRIC_SEPARATED, 1-bit CMYK, and native uint1 ImageSpec, which define the relevant source path, functions, state, and trigger. This issue is fixed in 3.1.16.0.

Technical POC Analysis

CWE-122 heap-based buffer overflow (advisory also lists CWE-131 incorrect calculation of buffer size and CWE-787 out-of-bounds write).

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

OpenImageIO, a widely-used image processing library, contains a heap-based out-of-bounds write vulnerability (CVE-2026-67549) that can be triggered when processing a specially crafted 1-bit CMYK TIFF file. Successful exploitation could lead to memory corruption, potentially enabling arbitrary code execution or denial of service in applications that rely on the library. Organizations using OpenImageIO in their image processing workflows should prioritize upgrading to version 3.1.16.0 to mitigate this high-severity risk.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 82% exploitable
Prevalence
Medium
widely used VFX/animation image I/O library, common in graphics pipelines not general IT
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 HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Open
Automatable· derived
No
Human Impact
High

Priority Score

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

CVE-2023-42299 CRITICAL POC
9.8 Nov 02

Buffer Overflow vulnerability in OpenImageIO oiio v.2.4.12.0 allows a remote attacker to execute arbitrary code and caus

CVE-2022-41838 CRITICAL POC
9.8 Dec 22

A code execution vulnerability exists in the DDS scanline parsing functionality of OpenImageIO Project OpenImageIO v2.4.

CVE-2022-41837 CRITICAL POC
9.8 Dec 22

An out-of-bounds write vulnerability exists in the OpenImageIO::add_exif_item_to_spec functionality of OpenImageIO Proje

CVE-2022-41794 CRITICAL POC
9.8 Dec 22

A heap based buffer overflow vulnerability exists in the PSD thumbnail resource parsing code of OpenImageIO 2.3.19.0. Ra

CVE-2022-41639 CRITICAL POC
9.8 Dec 22

A heap based buffer overflow vulnerability exists in tile decoding code of TIFF image parser in OpenImageIO master-branc

CVE-2022-38143 CRITICAL POC
9.8 Dec 22

A heap out-of-bounds write vulnerability exists in the way OpenImageIO v2.3.19.0 processes RLE encoded BMP images. Rated

CVE-2022-41649 CRITICAL POC
9.1 Dec 22

A heap out of bounds read vulnerability exists in the handling of IPTC data while parsing TIFF images in OpenImageIO v2.

CVE-2023-42295 HIGH POC
8.8 Oct 23

An issue in OpenImageIO oiio v.2.4.12.0 allows a remote attacker to execute arbitrary code and cause a denial of service

CVE-2022-43602 HIGH POC
8.1 Dec 22

Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO

CVE-2022-43601 HIGH POC
8.1 Dec 22

Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO

CVE-2022-43600 HIGH POC
8.1 Dec 22

Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO

CVE-2022-43599 HIGH POC
8.1 Dec 22

Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO

Vendor StatusVendor

SUSE

Severity: Important
Product Status
openSUSE Tumbleweed Fixed

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