OpenEXR
CVE-2025-12840
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver malicious EXR via web or file share
-
DeliveryUser opens file in OpenEXR-backed app
-
ExploitOversized data copied to heap buffer
-
ExecutionTrigger heap buffer overflow in parser
-
ImpactExecute arbitrary code as current user
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 an attacker-crafted EXR file (or load a page/asset that causes an application to parse one) using software built on the OpenEXR library; the specific trigger is OpenEXR's failure to validate the length of user-supplied data before copying it into a heap buffer during EXR parsing. Limiting factors: user interaction is mandatory (UI:R) - there is no server-side or network-automatic path - and the vector is local (AV:L), so an attacker cannot reach a victim without getting them to process a malicious file. No authentication or special privileges are required of the attacker (PR:N). Realistic exposure is concentrated in VFX/rendering/image-processing workflows and any application that auto-ingests untrusted .exr files. |
| Impact | This is a genuine but not emergency-grade priority. The CVSS 3.0 base score of 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) reflects a classic client-side file-parsing memory-corruption flaw: no privileges needed (PR:N) and low complexity (AC:L), but the vector is Local (AV:L) and requires user interaction (UI:R), meaning the victim must open a malicious EXR file or visit a page that triggers parsing. Note the apparent tension flagged by the description: it labels this 'Remote Code Execution' and references 'remote attackers,' yet the CVSS vector is AV:L - this is consistent with ZDI's standard modeling of file-format bugs, where delivery is remote (download/web) but exploitation is local because it depends on the target opening the content; the attack is not network-reachable or server-side. Corroborating signals point to lower real-world urgency: EPSS is only 0.19% (9th percentile), the CVE is NOT on CISA KEV, and no public exploit code is indicated in the provided data. Impact is high (C:H/I:H/A:H, code execution in the context of the parsing process), so the ceiling is serious, but absence of active exploitation and the user-interaction requirement place this as a standard patch-cycle item rather than an out-of-band emergency - prioritize for software bundling OpenEXR that routinely ingests untrusted .exr files. |
| Exploit ScenarioDerived | An attacker crafts a malicious EXR image with a manipulated length field and delivers it via a website, email attachment, or shared asset. When a user opens the file in an application built on OpenEXR, the parser copies oversized user-supplied data into an undersized heap buffer, corrupting memory and enabling arbitrary code execution in the context of that process. No public exploit code is identified at time of analysis, but the flaw was reported through ZDI (ZDI-25-991) with technical detail. |
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 the Academy Software Foundation's OpenEXR library allows an attacker to execute arbitrary code in the context of the process that parses a crafted .exr file, but only after the victim opens the file or loads an asset that triggers EXR parsing. The attack vector is local and user interaction is mandatory (CVSS:3.1/AV:L/AC:L/PR:N/UI:R), so there is no server-side or network-automatic path; realistic exposure is limited to VFX, rendering, image-processing, and other workflows that auto-ingest untrusted EXR content. No public exploit code was identified at time of analysis and no CISA KEV entry exists, while EPSS is very low at 0.19% (9th percentile), making this a genuine but not emergency-grade priority.
RemediationAI
No vendor-released patch was identified in the available data at time of analysis, so remediation must begin with confirming a fixed OpenEXR release with the project (Academy Software Foundation) and the ZDI advisory at https://www.zerodayinitiative.com/advisories/ZDI-25-991/, then upgrading every application, plugin, and render node that links OpenEXR rather than only the library package. Until a fixed version is confirmed, apply specific compensating controls: block automatic parsing of untrusted .exr files (disable EXR thumbnailing, preview generation, watch-folder ingestion, and web upload paths that hand files directly to OpenEXR) and require manual review of EXR assets, accepting the workflow slowdown this introduces; run EXR parsing in a sandboxed, low-privilege worker or container with no access to credentials, render farm control planes, or production storage, accepting the added operational complexity; and where feasible gate EXR ingestion behind a converter that runs with seccomp/AppArmor confinement and memory-safety mitigations (ASan-instrumented builds in test pipelines), accepting reduced throughput. Because exploitation requires user interaction and a local vector, user awareness about opening unsolicited .exr files is a useful secondary control but cannot replace fixing the parser.
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 the Academy Software Foundation's reference implementation of the EXR high-dynamic-range image format, widely embedded in VFX pipelines, renderers, compositors, and image-conversion tools. The flaw is CWE-122 (heap-based buffer overflow): during EXR parsing, user-supplied length data is not validated before it is copied into a heap-allocated buffer, so a malicious file can cause an out-of-bounds write on the heap and, with careful layout control, redirect execution. The CPE cpe:2.3:a:openexr:openexr:*:*:*:*:*:*:*:* identifies the OpenEXR library itself as the affected component without pinning a specific version range, and the ZDI advisory (ZDI-25-991 / ZDI-CAN-27948) attributes the finding to Trend Micro's Zero Day Initiative. Because the vulnerable code is a library, the blast radius extends to any application linked against OpenEXR that parses untrusted .exr files, and the practical attack surface is file-parsing rather than a network service. The assessed CVSS:3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) confirms that exploitation requires local file delivery plus user interaction, and that a successful trigger yields high confidentiality, integrity, and availability impact within the parsing process.
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 needing no privileges (PR:N) but mandatory user action to open the file, hence AV:L and UI:R; memory corruption yields full code execution, so C/I/A all High.
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-27948.
Executive ViewAI
OpenEXR, a library used in VFX, rendering, and image-processing workflows, contains a heap-based buffer overflow that can allow arbitrary code execution in the parsing process when a user opens a crafted .exr file. Exposure is limited to local, user-interaction scenarios involving untrusted EXR content, but affected teams could face workstation compromise and pipeline disruption; no public exploit has been identified and no vendor patch is currently available.
No vendor-released patch identified at time of analysis; interim mitigations include disabling auto-loading and thumbnailing of EXR files, sandboxing or isolating EXR parsing, restricting ingestion of untrusted .exr content, enforcing least privilege, and monitoring vendor advisories for a fixed OpenEXR release.
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