OpenEXR
CVE-2025-12839
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver malicious EXR file to victim
-
DeliveryVictim opens or app renders file
-
ExploitOverlong field overflows heap buffer
-
ExecutionCorrupt heap and hijack control flow
-
ImpactExecute code as current process
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 open or render an attacker-crafted OpenEXR (.exr) file through an application that uses the OpenEXR library for EXR parsing (UI:R); there is no remote network-service exposure. The specific trigger is an EXR file whose user-supplied data length is not validated before being copied into a heap buffer. Limiting factors: user interaction is mandatory, exploitation is local to the process that parses the file (AV:L, scope unchanged), and impact is bounded by the privileges of that process. Risk is highest in environments that automatically ingest or thumbnail untrusted EXR files (render farms, media/asset pipelines, image viewers with auto-preview), and lower where EXR files come only from trusted sources. |
| Impact | Signals are consistent and point to a genuine but NOT emergency-tier issue. The CVSS 3.0 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 7.8 HIGH) describes a local attack vector requiring user interaction but no privileges, with full confidentiality/integrity/availability impact once triggered - the standard profile for a client-side file-parsing RCE. Note the apparent tension: the description uses the phrase 'remote attackers,' but the vector is correctly AV:L because exploitation requires the victim to locally open or render a malicious EXR file rather than the attacker reaching the code over the network - these are reconcilable (attacker-supplied file delivered remotely, parsed locally), not a true contradiction. Exploitation signals are weak: EPSS is only 0.19% (9th percentile), there is no CISA KEV listing, and no public exploit code is referenced - so there is no public exploit identified at time of analysis. The vulnerability was reported privately through Trend Micro's Zero Day Initiative (ZDI-CAN-27947 / ZDI-25-990), which indicates credible, vetted research rather than opportunistic disclosure. Net: this is a real, patch-worthy memory-corruption RCE in a widely-embedded library, but the user-interaction requirement and low EPSS mean it is a routine-priority fix for most environments, elevated only where untrusted EXR files are processed automatically (e.g., render farms, thumbnailers, media pipelines). |
| Exploit ScenarioDerived | An attacker crafts a malicious OpenEXR (.exr) image whose internal length fields trigger a heap-based buffer overflow when parsed, then delivers it via a web page, email attachment, or shared asset. When a victim opens or an application auto-renders the file, the overflow corrupts heap memory and allows code execution in the context of the parsing process. No public proof-of-concept is referenced, and exploitation requires the victim to open/render the attacker-supplied file (UI:R). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Heap-based buffer overflow in Academy Software Foundation OpenEXR allows unauthenticated attackers to execute arbitrary code in the context of the parsing process when a victim opens a crafted .exr file, requiring user interaction and local access to the file. The flaw stems from missing validation of user-supplied length data before a heap copy; no public exploit identified at time of analysis, and EPSS is low at 0.19% (9th percentile). Risk concentrates in pipelines that automatically ingest or thumbnail untrusted EXR assets.
RemediationAI
No vendor-released patch was identified in the provided data at time of analysis; monitor the ZDI advisory at https://www.zerodayinitiative.com/advisories/ZDI-25-990/ and the OpenEXR project for an official fixed release before upgrading. Until a patch is confirmed, restrict automatic processing and thumbnailing of untrusted .exr files-disable EXR preview generation in image viewers and asset management tools, and require explicit user action for opening files from untrusted sources-accepting reduced workflow automation as the trade-off. For pipelines that must process external EXR assets, run parsing in a sandboxed or low-privilege isolated process/container with no network access and limited filesystem write permissions, which contains the impact of a heap overflow at the cost of added operational overhead. Enforce least privilege on any process that opens EXR files and log or block EXR ingestion from email/web downloads where feasible. These are compensating controls, not a substitute for the eventual vendor fix.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
OpenEXR is an image file format and library maintained by the Academy Software Foundation, widely used in visual effects and media pipelines for high-dynamic-range images. CVE-2025-12839 is a CWE-122 heap-based buffer overflow in the EXR parser: user-supplied length data is not properly validated before being copied into a heap buffer, so a crafted file can overwrite heap memory. The CVSS:3.1 vector AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H confirms the attack is local to the parsing process, requires user interaction to open the file, is unauthenticated, and yields high confidentiality, integrity, and availability impact within the same security scope; the CPE cpe:2.3:a:openexr:openexr:*:*:*:*:*:*:*:* indicates no version constraint was provided, so all OpenEXR versions should be treated as potentially affected until vendor guidance is available. The issue was reported through Trend Micro ZDI as ZDI-CAN-27947 / ZDI-25-990.
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
AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
File-parsing RCE: AV:L because the victim must locally open the file, UI:R for that action, PR:N as no auth is needed, and heap-overflow code execution yields full C/I/A.
Primary rating from Vendor (trendmicro).
CVSS VectorVendor: trendmicro
DescriptionCVE.org
Academy Software Foundation OpenEXR EXR File Parsing Heap-based Buffer Overflow Remote Code Execution Vulnerability. This vulnerability allows remote attackers to execute arbitrary code on affected installations of Academy Software Foundation OpenEXR. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file.
The specific flaw exists within the parsing of EXR files. The issue results from the lack of proper validation of the length of user-supplied data prior to copying it to a heap-based buffer. An attacker can leverage this vulnerability to execute code in the context of the current process. Was ZDI-CAN-27947.
Executive ViewAI
OpenEXR carries a high-severity code-execution exposure that can affect workstations and automated content services when crafted .exr files are opened, with the greatest business risk in media, design, and asset pipelines that routinely ingest external files. A successful incident could disrupt production, expose sensitive assets, or allow unauthorized code execution under the parsing account. No vendor-released patch identified at time of analysis, and no public exploit identified at time of analysis; leadership should prioritize untrusted-file intake controls and reduce automatic EXR processing while remediation is tracked.
No vendor-released patch identified at time of analysis; restrict or disable automatic ingestion and thumbnail generation for untrusted .exr files, require manual review of external EXR assets, run parsing in a low-privilege sandbox or container, disable preview handlers where feasible, and quarantine or block external .exr files until a fixed OpenEXR release is available.
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.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Affected Products (CPE)CVE.org
makeMultiView.cpp in exrmultiview in OpenEXR 2.3.0 has an out-of-bounds write, leading to an assertion failure or possib
Out-of-bounds heap write in OpenEXR's CompositeDeepScanLine::readPixels lets a crafted multi-part deep-scanline EXR file
In OpenEXR 2.2.0, a crafted image causes a heap-based buffer over-read in the hufDecode function in IlmImf/ImfHuf.cpp du
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
There's a flaw in OpenEXR's ImfDeepScanLineInputFile functionality in versions prior to 3.0.5. Rated medium severity (CV
A head-based buffer overflow exists in Academy Software Foundation OpenEXR 2.3.0 in writeTileData in ImfTiledOutputFile.
A Null Pointer Deference issue exists in Academy Software Foundation OpenEXR 2.3.0 in generatePreview in makePreview.cpp
A heap-based buffer overflow vulnerability exists in Academy Software Foundation OpenEXR 2.3.0 in chunkOffsetReconstruct
An issue was discovered in OpenEXR before 2.4.1. Rated medium severity (CVSS 5.5), this vulnerability is no authenticati
An issue was discovered in OpenEXR before 2.4.1. Rated medium severity (CVSS 5.5), this vulnerability is no authenticati
An issue was discovered in OpenEXR before 2.4.1. Rated medium severity (CVSS 5.5), this vulnerability is no authenticati
An issue was discovered in OpenEXR before 2.4.1. Rated medium severity (CVSS 5.5), this vulnerability is no authenticati
NVD
CVE.org
EPSS
GitHub PoC
Exploit-DB