Skip to main content

PyOpenEXR CVE-2026-68513

| EUVDEUVD-2026-65736 HIGH
Heap-based Buffer Overflow (CWE-122)
2026-08-25 GitHub_M
7.1
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Deliver crafted EXR containing colliding literal and prefixed RGB channel names
  2. Delivery
    Victim or automated pipeline calls OpenEXR.File(path) with default separate_channels=False
  3. Exploit
    channelNameToRGBA() maps both 'left' and 'left.{R,G,B}' to the same group key
  4. Execution
    Undersized two-dimensional NumPy array allocated for coalesced RGB slices
  5. Persist
    Out-of-bounds heap write occurs during pixel decode
  6. Impact
    Process crash or heap 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 that the target application invoke OpenEXR.File() using PyOpenEXR with separate_channels=False, which is the default and requires no special configuration to trigger. The crafted EXR file must contain both a literal channel whose name matches the group key produced by coalescing a set of dot-prefixed RGB channels - for example, a channel named 'left' alongside channels 'left.R', 'left.G', and 'left.B'. The CVSS vector specifies AV:L (the file must be accessible on the local system or within a process's file-open path) and UI:R (a user or automated job must invoke the open call). Applications that explicitly pass separate_channels=True are fully protected as the coalescing path is not entered. No authentication or elevated privileges are required (PR:N). Exploitation is further limited to integrity and availability impact only - no confidentiality data exposure results from the heap overflow. In unattended pipeline deployments that ingest untrusted EXR submissions automatically, the UI:R barrier is effectively absent, making those environments the highest-risk targets.

Impact

The CVSS 3.1 score of 7.1 (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:H) places this vulnerability in the file-borne exploitation class: an attacker cannot exploit it over the network without first convincing a user or automated system to process a malicious EXR file, which limits opportunistic mass-scale attacks compared to network-reachable vulnerabilities. No EPSS score was provided in the input; with AV:L and UI:R, exploitation probability in a general enterprise context is low. The vulnerability is not listed in the CISA KEV catalog and no public proof-of-concept exploit has been identified, further reducing urgency for most organizations. However, PyOpenEXR is commonly embedded in automated rendering pipelines and asset-ingest systems that process untrusted artist-submitted files without human review - in these pipeline contexts the UI:R barrier is effectively removed because file processing is programmatic, which meaningfully raises practical exploitability above what the raw CVSS vector implies. SSVC assessment: exploitation status is none confirmed, automatable is conditionally yes in unattended ingest pipelines, technical impact is partial (integrity and availability, no confidentiality). Studios and organizations running automated EXR ingestion should treat this with higher urgency than a simple 7.1 local score would suggest.

Exploit ScenarioDerived

An attacker crafts a flat scanline EXR file containing channels named 'left', 'left.R', 'left.G', and 'left.B', then delivers it to a VFX studio's automated asset-ingest pipeline or persuades a user to open it in a Python-based compositing tool. When the application calls OpenEXR.File(path) with the default separate_channels=False, the coalescing logic collides the literal 'left' key with the synthesized RGB group key 'left', allocates a NumPy array sized for only one channel's data, and then writes three additional RGB pixel planes into it during decode, causing an out-of-bounds heap write that crashes the process or corrupts adjacent heap metadata. No public proof-of-concept exploit code has been identified at time of analysis.

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 – Aug 25, 2026

Heap buffer overflow in PyOpenEXR versions 3.3.0-3.3.12 and 3.4.0-3.4.13 allows an attacker to corrupt process memory by supplying a crafted EXR image file containing conflicting literal and prefixed RGB channel names. When the Python wrapper decodes such a file under the default separate_channels=False mode, a channel-name key collision causes the coalescing logic to reuse an undersized NumPy array and write pixel data out of bounds on the heap, producing high integrity and availability impact with no confidentiality exposure. No public exploit code has been identified and no active exploitation is confirmed; patched releases 3.3.13 and 3.4.14 are available from the Academy Software Foundation.

RemediationAI

The primary fix is to upgrade to OpenEXR 3.3.13 (for the 3.3.x series) or 3.4.14 (for the 3.4.x series), both of which introduce collision detection in the renamed validateCoalescedChannels() function and reject ambiguous EXR files before any pixel data is read. Upstream fix commits are at https://github.com/AcademySoftwareFoundation/openexr/commit/c1f3ec0d91cfa5a8035ecd00920835ac76e01640 and https://github.com/AcademySoftwareFoundation/openexr/commit/d134e3cd81a2e343f2919e86bf949f576b1ab16a; the security advisory is at https://github.com/AcademySoftwareFoundation/openexr/security/advisories/GHSA-rw5h-3q4v-c3vc. For applications that cannot immediately upgrade, passing separate_channels=True to OpenEXR.File() bypasses the coalescing path entirely and eliminates the collision condition; however, this changes the returned channel dictionary structure from merged RGB arrays to individual per-channel entries, requiring downstream code changes. A second compensating control for automated ingestion pipelines is to pre-screen EXR channel headers and reject files whose channel lists contain both a bare name and corresponding dot-prefixed RGB variants before decoding pixels; this requires custom validation logic but avoids restructuring the calling code.

Affected VersionsENISA

OpenEXR 3.3.0, < 3.3.13
OpenEXR 3.4.0, < 3.4.14

Affected Packages

euvd openexr_3_3_0 fix: 3.3.13
euvd openexr_3_4_0 fix: 3.4.14

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

PyOpenEXR is the official C++-backed Python binding for the OpenEXR high-dynamic-range image format (CPE: cpe:2.3:a:academysoftwarefoundation:openexr:*:*:*:*:*:*:*:*), the Academy Software Foundation's reference implementation widely deployed in VFX and motion-picture pipelines. The root cause is CWE-122 (Heap-based Buffer Overflow) in the channel-coalescing path of PyOpenEXR.cpp. When separate_channels=False (the default), the wrapper calls channelNameToRGBA() for every physical channel name and merges the results into a shared RGB NumPy array. The pre-existing validation function validateCoalescedChannelTypes() checked only for pixel-type mismatches but did not detect name collisions between literal channel entries (e.g., 'left') and the synthetic group keys produced by stripping dot-prefixed RGB suffixes from prefixed channels (e.g., 'left.R', 'left.G', 'left.B' → group key 'left'). A crafted EXR exploiting this gap causes the wrapper to allocate an array sized for only one channel and then attempt to write three additional RGB slices into it, producing an out-of-bounds heap write during OpenEXR.File() pixel decode. The fix in commits c1f3ec0 and d134e3c renames the function to validateCoalescedChannels() and introduces a std::set<std::string> (coalescedKeys) that detects collisions before any pixel I/O and throws std::invalid_argument, guiding callers to use separate_channels=True instead.

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

File-borne local attack requiring a user or pipeline to open the crafted EXR; no confidentiality impact from the heap overflow alone.

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

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

Lifecycle Timeline

2
Patch available
Aug 25, 2026 - 21:04 EUVD
CVE Published
Aug 25, 2026 - 19:06 cve.org
HIGH 7.1

DescriptionCVE.org

OpenEXR is the reference implementation and specification for the EXR image format, widely used in the motion picture industry. Versions 3.3.0 through 3.3.12 and 3.4.0 through 3.4.13 contain a heap buffer overflow in PyOpenEXR triggered by a channel-name key collision between literal and prefixed RGB channels. When separate_channels=false, PyOpenEXR maps each physical channel name through channelNameToRGBA() and coalesces the results into a shared RGB array. A crafted flat scanline EXR that contains both a literal channel such as left and prefixed channels such as left.R, left.G, and left.B causes these names to collide, so the wrapper reuses an undersized two-dimensional NumPy array for the coalesced RGB slices and writes out of bounds when OpenEXR.File(path) decodes the pixels. This issue is fixed in versions 3.3.13 and 3.4.14.

Executive ViewAI

Why It Matters

PyOpenEXR versions 3.3.0-3.3.12 and 3.4.0-3.4.13 contain a heap buffer overflow vulnerability that enables memory corruption through malformed image files. No public exploit identified at time of analysis. Organizations processing untrusted EXR files face denial of service and data integrity risks until patched.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Medium
widely used in VFX and film production pipelines
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.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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

36
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +36
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-2018-18444 HIGH POC
8.8 Oct 17

makeMultiView.cpp in exrmultiview in OpenEXR 2.3.0 has an out-of-bounds write, leading to an assertion failure or possib

CVE-2026-27622 HIGH POC
8.4 Mar 03

Out-of-bounds heap write in OpenEXR's CompositeDeepScanLine::readPixels lets a crafted multi-part deep-scanline EXR file

CVE-2017-12596 HIGH POC
7.8 Aug 07

In OpenEXR 2.2.0, a crafted image causes a heap-based buffer over-read in the hufDecode function in IlmImf/ImfHuf.cpp du

CVE-2026-26981 MEDIUM POC
6.5 Feb 24

OpenEXR versions 3.3.0-3.3.6 and 3.4.0-3.4.4 are vulnerable to a heap buffer overflow in file parsing due to improper in

CVE-2021-3598 MEDIUM POC
5.5 Jul 06

There's a flaw in OpenEXR's ImfDeepScanLineInputFile functionality in versions prior to 3.0.5. Rated medium severity (CV

CVE-2020-16589 MEDIUM POC
5.5 Dec 09

A head-based buffer overflow exists in Academy Software Foundation OpenEXR 2.3.0 in writeTileData in ImfTiledOutputFile.

CVE-2020-16588 MEDIUM POC
5.5 Dec 09

A Null Pointer Deference issue exists in Academy Software Foundation OpenEXR 2.3.0 in generatePreview in makePreview.cpp

CVE-2020-16587 MEDIUM POC
5.5 Dec 09

A heap-based buffer overflow vulnerability exists in Academy Software Foundation OpenEXR 2.3.0 in chunkOffsetReconstruct

CVE-2020-11765 MEDIUM POC
5.5 Apr 14

An issue was discovered in OpenEXR before 2.4.1. Rated medium severity (CVSS 5.5), this vulnerability is no authenticati

CVE-2020-11764 MEDIUM POC
5.5 Apr 14

An issue was discovered in OpenEXR before 2.4.1. Rated medium severity (CVSS 5.5), this vulnerability is no authenticati

CVE-2020-11763 MEDIUM POC
5.5 Apr 14

An issue was discovered in OpenEXR before 2.4.1. Rated medium severity (CVSS 5.5), this vulnerability is no authenticati

CVE-2020-11762 MEDIUM POC
5.5 Apr 14

An issue was discovered in OpenEXR before 2.4.1. Rated medium severity (CVSS 5.5), this vulnerability is no authenticati

Vendor StatusVendor

SUSE

Severity: Important
Product Status
openSUSE Tumbleweed Fixed
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Performance Computing 12 Affected
SUSE Linux Enterprise Module for Desktop Applications 15 SP7 Affected
SUSE Linux Enterprise Server 15 SP7 Affected

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