Skip to main content

OpenImageIO CVE-2026-63638

| EUVDEUVD-2026-83132 HIGH
Out-of-bounds Write (CWE-787)
2026-09-18 GitHub_M
8.3
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Craft Cineon file with bit depth 26
  2. Delivery
    Deliver file to OIIO-based pipeline
  3. Exploit
    Victim opens/parses image
  4. Execution
    Depth mismatch skips bounds sizing
  5. Persist
    Heap out-of-bounds write past pixel buffer
  6. Impact
    Memory corruption / potential code execution

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires the target application to open and parse an attacker-supplied Cineon (.cin) image via OpenImageIO's cineon.imageio reader on an affected version prior to 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1. The specific trigger is a Cineon file declaring an unsupported component bit depth (e.g. 26) that CineonInput::open() maps to a 32-bit ImageSpec while libcineon's ComponentDataSize returns an 8-byte size. Limiting factors: exploitation needs user/processing interaction (UI:R) - a victim or automated pipeline must actually decode the crafted file - and depends on the deployment ingesting untrusted Cineon input; environments that never process external .cin files are effectively unexposed. No authentication is required against the parsing process itself (PR:N).

Impact

The vendor CVSS3.1 score is 8.3 (High) with vector AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:H. The network vector is realistic in the sense that malicious Cineon (.cin) files are delivered over the network (asset pipelines, downloads, render-farm ingestion), but exploitation is NOT service-facing remote code execution against a listening daemon - it requires a victim application to open/parse the crafted file, which is why UI:R (user/processing interaction) is correctly set. This is a classic file-format parser memory-corruption bug (CWE-787 heap out-of-bounds write): a crafted Cineon image declares an unsupported component bit depth of 26, CineonInput::open() maps it to a 32-bit ImageSpec while libcineon's ComponentDataSize maps it to an 8-byte value, so read_native_scanline() writes attacker-controlled data past the 4-byte-per-pixel buffer. No EPSS score, no CISA KEV listing, and no public exploit (POC) are present in the supplied intelligence; therefore this is 'no public exploit identified at time of analysis.' The I:H/A:H rating reflects that heap corruption can plausibly lead to code execution or crash, but the input contains no evidence of a working control-flow-hijack exploit - the confirmed observable behavior in the vendor's own test harness is an assert/abort (DoS). Net: a genuinely serious memory-safety flaw worth patching promptly in any pipeline that ingests untrusted Cineon files, but there is no signal of active or automatable mass exploitation, so it is a patch-in-normal-cycle priority rather than an emergency, especially for environments that never process externally-sourced .cin files.

Exploit ScenarioDerived

An attacker crafts a malicious Cineon (.cin) file whose header declares an unsupported per-channel bit depth of 26 and delivers it into a VFX/animation asset pipeline, render farm, or image-conversion service that uses OpenImageIO. When the target application opens the file, CineonInput::read_native_scanline() writes attacker-controlled bytes beyond the allocated 4-byte-per-pixel buffer, corrupting the heap. No public exploit code is identified; the vendor regression test demonstrates the trigger causing an abort/error, with memory corruption as the underlying primitive.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% 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 write in OpenImageIO's Cineon image reader (cineon.imageio) allows memory corruption when the library decodes a crafted .cin file that declares an unsupported per-channel bit depth, such as 26. Affected deployments are those running OpenImageIO versions prior to 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1, and exploitation requires that a victim or an automated pipeline actually open and parse the attacker-supplied Cineon file (CVSS vector PR:N with UI:R). The flaw is rated High (CVSS 3.1 base 8.3, AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:H) and no public exploit code has been identified at time of analysis; vendor-released fixes are available in 3.0.21.0, 3.1.16.0, and 3.2.0.3-beta1.

RemediationAI

Vendor-released patches are available: upgrade to OpenImageIO 3.0.21.0 (3.0.x branch), 3.1.16.0 (3.1.x branch), or 3.2.0.3-beta1 (3.2.x branch), which incorporate PR 5283 / commit 6f2b2e85b3b3933ccc5a46303d5535f99bfa39fb and reject any per-channel bit depth other than 8, 10, 12, 16, 32 or 64 with an explicit 'Invalid bitdepth' error rather than writing past the caller buffer. Details are in the advisory at https://github.com/AcademySoftwareFoundation/OpenImageIO/security/advisories/GHSA-9hxv-jvgr-3x8g and the release tags https://github.com/AcademySoftwareFoundation/OpenImageIO/releases/tag/v3.0.21.0 and https://github.com/AcademySoftwareFoundation/OpenImageIO/releases/tag/v3.1.16.0. If upgrading cannot be done immediately, compensating controls with clear trade-offs are: (1) disable or unload the Cineon reader plugin (e.g. remove/rename cineon.imageio.so or block the 'cineon' format in the application's supported-format configuration) if no legitimate .cin workflow exists - this eliminates the attack surface entirely but removes all Cineon support; (2) gate any untrusted .cin input through a pre-parser or sanitizer that rejects files whose component bit depth is not in {8,10,12,16,32,64} before they reach OpenImageIO, which adds an ingest step and must be kept in sync with the format spec; (3) isolate decoding of untrusted images in a sandboxed, low-privilege subprocess or container with heap hardening and strict resource limits, which does not fix the bug but limits the blast radius of the corruption, at the cost of throughput and pipeline complexity. Because exploitation requires the crafted file to actually be opened (UI:R) and there is no public exploit code identified at time of analysis, prioritization should focus on pipelines that automatically ingest untrusted Cineon files.

Affected VersionsENISA

OpenImageIO < 3.0.21.0
OpenImageIO 3.1.0.0, < 3.1.16.0
OpenImageIO 3.2.0.0-dev, < 3.2.0.3-beta1

Affected Packages

euvd openimageio fix: 3.0.21.0, 3.1.16.0
euvd openimageio_3_2_0_0_dev fix: 3.2.0.3-beta1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages 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 that ships a reader plugin for Kodak Cineon (.cin) files under src/cineon.imageio/cineoninput.cpp, backed by a vendored copy of the libcineon library. The root cause is a size-classification mismatch between the two layers, tracked as CWE-787 (out-of-bounds write). CineonInput::open() reads a per-channel component bit depth from the file header and, for values it deems plausible, builds an ImageSpec; the original guard only checked that the value fell in the range 1 to 32, so a value such as 26 passed validation and was mapped to a 32-bit (4-byte-per-pixel) ImageSpec. libcineon's ComponentDataSize()/ComponentByteCount() helpers, however, only recognize a fixed set of depths (8, 10, 12, 16, 32, 64) and, for an unrecognized depth like 26, return an 8-byte component size. When CineonInput::read_native_scanline() then writes pixels using the library's larger component size into a caller buffer allocated for 4 bytes per pixel, attacker-controlled data lands past the end of the heap allocation, producing memory corruption. The upstream fix (PR 5283, commit 6f2b2e85b3b3933ccc5a46303d5535f99bfa39fb) replaces the loose range check with an explicit whitelist switch over 8, 10, 12, 16, 32 and 64 bits, rejecting anything else with a proper 'Invalid bitdepth' error instead of asserting or corrupting memory deeper inside the vendored library; the accompanying regression test uses src/broken_bitdepth2.cin. The CPE cpe:2.3:a:academysoftwarefoundation:openimageio:*:*:*:*:*:*:*:* identifies Academy Software Foundation OpenImageIO as the affected project.

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

Crafted file delivered over network but must be opened by victim (AV:N/UI:R); no auth to the parser (PR:N); heap OOB write yields high integrity/availability impact and limited memory disclosure (C:L).

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

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
High
Availability
High

Lifecycle Timeline

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

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.0.21.0, 3.1.16.0, and 3.2.0.3-beta1, A crafted cineon image can declare unsupported component bit depth 26. cineoninput::open() maps it to a 32-bit imagespec, but libcineon maps the unsupported depth to an 8-byte value, so cineoninput::read_native_scanline() causes attacker-controlled data to be written beyond the 4-byte-per-pixel caller buffer, resulting in a heap out-of-bounds write and memory corruption. The affected implementation is identified by src/cineon.imageio/cineoninput.cpp, CineonInput::open(), CineonInput::read_native_scanline(), ComponentDataSize(), bit depth 26, and ImageSpec, which define the relevant source path, functions, state, and trigger. This issue is fixed in versions 3.0.21.0, 3.1.16.0, and 3.2.0.3-beta1.

Technical POC Analysis

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, an image-decoding library widely embedded in VFX, rendering, broadcast, and media asset pipelines, contains a heap memory-corruption flaw in its Cineon (.cin) reader that is triggered whenever a crafted image file is opened by a user or an automated processing job. Any team that ingests externally supplied Cineon assets - studios, post-production vendors, and any group running third-party image pipelines - is in scope, and successful corruption could allow an attacker to run code with the privileges of the processing service or crash production workflows. Leadership should care because the exposure is concentrated in creative and content-supply operations that routinely handle untrusted files, and remediation requires coordinated library upgrades across many interdependent tools.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 85% exploitable
Prevalence
Medium
de facto VFX/animation image I/O library, widely embedded but industry-focused, not universal
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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

Priority Score

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

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

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

Product Status
openSUSE Tumbleweed Fixed

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