Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft Cineon file with bit depth 26
-
DeliveryDeliver file to OIIO-based pipeline
-
ExploitVictim opens/parses image
-
ExecutionDepth mismatch skips bounds sizing
-
PersistHeap out-of-bounds write past pixel buffer
-
ImpactMemory 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:H
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).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.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
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.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
More in Openimageio
View allBuffer Overflow vulnerability in OpenImageIO oiio v.2.4.12.0 allows a remote attacker to execute arbitrary code and caus
A code execution vulnerability exists in the DDS scanline parsing functionality of OpenImageIO Project OpenImageIO v2.4.
An out-of-bounds write vulnerability exists in the OpenImageIO::add_exif_item_to_spec functionality of OpenImageIO Proje
A heap based buffer overflow vulnerability exists in the PSD thumbnail resource parsing code of OpenImageIO 2.3.19.0. Ra
A heap based buffer overflow vulnerability exists in tile decoding code of TIFF image parser in OpenImageIO master-branc
A heap out-of-bounds write vulnerability exists in the way OpenImageIO v2.3.19.0 processes RLE encoded BMP images. Rated
A heap out of bounds read vulnerability exists in the handling of IPTC data while parsing TIFF images in OpenImageIO v2.
An issue in OpenImageIO oiio v.2.4.12.0 allows a remote attacker to execute arbitrary code and cause a denial of service
Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO
Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO
Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO
Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO
Same weakness CWE-787 – Out-of-bounds Write
View allSame technique Buffer Overflow
View allVendor StatusVendor
SUSE
| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
EUVD-2026-83132
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB