Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft tiled EXR with non-tile-multiple width
-
DeliveryDeliver file to victim pipeline
-
ExploitVictim app reads partial edge-tile rectangle
-
ExecutionWrong scanline stride overruns caller buffer
-
ImpactHeap out-of-bounds write and memory corruption
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 victim to read/process a crafted tiled OpenEXR image whose width is NOT an exact multiple of its tile width, and specifically to read a partial edge-tile rectangle via OpenEXRInput::read_native_tiles() (both the classic and OpenEXR-Core readers in src/openexr.imageio/exrinput.cpp are affected). The trigger is that source rows are spaced by the padded whole-tile scanline_stride while the caller's buffer is sized to the requested rectangle width, so the copy overruns. Limiting factors: local attack vector (AV:L) with required user interaction (UI:R) - an operator or automated pipeline must actually open/decode the malicious file; no authentication is needed (PR:N). Not exploitable against builds already at 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1. |
| Impact | This is a genuine memory-corruption bug (CWE-122 heap out-of-bounds write) rather than a high-CVSS-but-low-real-risk issue, but its exploitability is bounded by the CVSS attack vector. The vector CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H is local with required user interaction - the attacker cannot reach the code remotely on their own; a victim must open or process a crafted tiled OpenEXR file. The 7.8 base score is driven by the C:H/I:H/A:H impact triad typical of an out-of-bounds write, which is consistent with the described heap corruption. No EPSS score, no CISA KEV listing, and no weaponized public exploit are present in the provided data, so this is not confirmed as actively exploited; the signals point to a serious-but-not-yet-exploited memory-safety flaw. One caveat: while there is no packaged exploit, the fixing PR (#5295) ships a full regression test that deterministically generates a triggering image (a 127x129 tiled EXR with 64x64 tiles) and drives read_native_tiles(), so the trigger conditions and a reproducer are effectively public - lowering the effort to build a PoC even though none is cataloged as such. |
| Exploit ScenarioDerived | An attacker crafts a tiled OpenEXR image whose width is not a multiple of the tile width and delivers it to a victim (e.g., via an asset pack, render job, or shared VFX file). When the victim's OpenImageIO-based application reads a partial edge-tile rectangle, read_native_tiles() copies rows using the padded whole-tile stride, producing a heap out-of-bounds write and memory corruption. No packaged exploit is cataloged, but the upstream fix includes a regression test that generates a triggering image, so a reproducer is effectively public. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 18, 2026
Decoding a crafted tiled OpenEXR image with OpenImageIO releases prior to 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1 can corrupt the heap, because the tiled reader copies decoded rows into the caller's buffer using a padded whole-tile stride instead of the width of the requested rectangle; affected files are those whose width is not an exact multiple of the tile width and are read as a partial edge-tile rectangle. The flaw is reachable without any privileges (PR:N) but requires the victim to open or process the malicious file (UI:R) and is scored as a local-vector bug (AV:L), yielding CVSS 7.8 with high confidentiality, integrity, and availability impact; both the classic and OpenEXR-Core readers (src/openexr.imageio/exrinput.cpp and exrinput_c.cpp) are affected. No public exploit identified at time of analysis, and vendor fixes are available in the three named release lines.
RemediationAI
Vendor-released patch: upgrade to OpenImageIO 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1 (the 3.2 line requires the 3.2.0.3-beta1 or later build), per the advisory at https://github.com/AcademySoftwareFoundation/OpenImageIO/security/advisories/GHSA-xh5r-whph-qmc5; the fix is carried by pull request https://github.com/AcademySoftwareFoundation/OpenImageIO/pull/5295 and commit https://github.com/AcademySoftwareFoundation/OpenImageIO/commit/7303134f13b0f9dc738b8ecabecd8c9f90cbd4c9, which is the change to backport if you maintain a downstream fork and cannot move to a tagged release. Where upgrading is not immediately possible, treat untrusted tiled EXR as hostile input: reject or transcode tiled OpenEXR files at the ingestion boundary (e.g., strip tiling with oiiotool conversion in a disposable worker) before they reach an OpenImageIO-linked decoder, and block the extension at file/asset gateways - the trade-off is loss of tile-level streaming and higher peak memory during conversion. Alternatively, restrict image decoding to a sandboxed, least-privileged process with address-sanitizer coverage in staging, since AV:L/UI:R exploitation requires the victim process to actually decode the crafted file; note that neither full-image reads nor tile-aligned rectangles are affected, so filtering solely on tile alignment is not a reliable control and should not be used as a substitute for patching. Restricting who can supply assets to the pipeline lowers exposure but does not remediate already-deployed vulnerable binaries.
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 the image I/O library used throughout VFX, animation, and rendering pipelines, and it exposes image format plug-ins through ImageInput; the OpenEXR plug-in implements a tiled decoding path, OpenEXRInput::read_native_tiles() (and its OpenEXR-Core counterpart OpenEXRCoreInput::read_native_tiles()). OpenEXR tiled images store pixels in fixed-size tiles (e.g., 64x64), so a source buffer row is laid out with a scanline_stride padded up to the full tile width, while the destination buffer supplied by the caller is sized only to the requested rectangle. In the vulnerable code the destination pointer offset was computed with that padded whole-tile stride rather than the caller's user_scanline_bytes for the clamped rectangle, so when an image dimension is not a multiple of the tile size and a partial edge tile is requested, the memcpy of each row lands progressively further past the end of the caller's allocation. This is a classic CWE-122 heap-based buffer overflow: a write of size derived from one buffer's geometry applied to a differently sized buffer. The upstream fix introduces a separate dest_scanline_stride derived from the originally requested xend (requested_xend - xbegin) * pixelbytes, preserving the padded stride only for the internal temporary source rows, and adds the openexr-partialtile regression test that reads a 127x129 image tiled at 64x64 into an exactly sized buffer with guard bytes for both the classic and Core readers.
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:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Local file-parsing bug needing the victim to open a crafted EXR (AV:L, UI:R), no privileges (PR:N); a heap out-of-bounds write yields high confidentiality, integrity, and availability impact.
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 valid tiled openexr image whose width is not a multiple of its tile width can trigger an overflow when a caller reads a partial edge-tile rectangle. openexrinput::read_native_tiles() copies each row into the caller buffer using the padded whole-tile scanline_stride rather than user_scanline_bytes for the requested rectangle, resulting in a heap out-of-bounds write and memory corruption. The affected implementation is identified by src/openexr.imageio/exrinput.cpp, OpenEXRInput::read_native_tiles(), partial edge tile, user_scanline_bytes, and scanline_stride, 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-122 (heap-based buffer overflow, also tracked as 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
A heap-corruption flaw in OpenImageIO's OpenEXR tiled-image reader (CVE-2026-63422) is triggerable whenever a user or automated pipeline opens a specially crafted .exr file, and it affects both the classic and OpenEXR-Core reader code paths. Because the library is embedded throughout VFX, rendering, review, and digital-asset pipelines, any team ingesting third-party or untrusted image assets could face process crashes, corrupted output, or memory-safety exploitation on operator workstations and render nodes. Leadership should care because remediation requires coordinated library upgrades across many dependent applications, and a single malicious asset can compromise the integrity of production deliverables.
Vendor-fixed releases are named in the context (3.0.21.0, 3.1.16.0, 3.2.0.3-beta1) - apply vendor patch. Until every dependent application is rebuilt against a fixed build: process untrusted .exr assets only in sandboxed, low-privilege, containerized workers; block or quarantine externally sourced .exr files at email/web gateways and asset-ingest points; disable or defer automated batch decoding of untrusted image libraries; and monitor affected hosts for crashes and anomalous process behavior.
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.
A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.
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-122 – Heap-based Buffer Overflow
View allSame technique Buffer Overflow
View allVendor StatusVendor
SUSE
| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
EUVD-2026-83124
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB