Skip to main content

OpenImageIO CVE-2026-63422

| EUVDEUVD-2026-83124 HIGH
Heap-based Buffer Overflow (CWE-122)
2026-09-18 GitHub_M
7.8
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Craft tiled EXR with non-tile-multiple width
  2. Delivery
    Deliver file to victim pipeline
  3. Exploit
    Victim app reads partial edge-tile rectangle
  4. Execution
    Wrong scanline stride overruns caller buffer
  5. Impact
    Heap 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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

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

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

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

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

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.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

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

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Medium
widely-used VFX/animation image library and dependency, but not universally deployed
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.1%
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
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Product Status
openSUSE Tumbleweed Fixed

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