Skip to main content

OpenImageIO EUVDEUVD-2026-30410

| CVE-2026-43907 HIGH
Integer Overflow or Wraparound (CWE-190)
2026-05-14 GitHub_M
8.3
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Recon
    Craft DPX file with oversized pixel count
  2. Delivery
    Deliver to victim via email/file share
  3. Exploit
    Victim opens file in OpenImageIO-based app
  4. Install
    Integer overflow in buffer size calculation
  5. C2
    Undersized heap allocation
  6. Execute
    Full image data written via fread
  7. Impact
    Heap buffer overflow
  8. Step 8
    Code execution or crash

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
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

Requires victim to process a specially crafted DPX image file through an application using vulnerable OpenImageIO versions (3.0.x before 3.0.18.0 or 3.1.x before 3.1.13.0). The DPX file must specify pixel dimensions exceeding the integer overflow threshold (approximately 536 million pixels for kABGR descriptor or 715 million for kCbYCr descriptor based on the -4 and -3 multipliers respectively) while maintaining valid file structure to pass initial parsing. User interaction required - exploitation fails if file is not opened or processed by affected application. Attack complexity is low once crafted file is created, as no race conditions or non-default configurations are required. Exploitation effectiveness depends on heap memory layout and presence of modern exploit mitigations (ASLR, heap integrity checks); code execution may be unreliable on hardened systems but denial of service remains achievable.

Impact

Real-world risk is moderate-high despite the 8.3 CVSS score. The CVSS vector (AV:N/AC:L/PR:N/UI:R) indicates network-reachable attack surface with low complexity, but mandatory user interaction (opening a malicious DPX file) significantly constrains automated exploitation. The vulnerability requires the attacker to deliver a crafted DPX file and convince a victim to process it through an OpenImageIO-based application - classic file format attack vector common in targeted attacks against media production environments. EPSS data not provided, but the combination of detailed public technical disclosure (GitHub Security Advisory GHSA-cq46-hp4h-cvfr) and straightforward exploitation logic suggests proof-of-concept development is feasible. No CISA KEV listing indicates no confirmed widespread or targeted exploitation. Technical impact is severe (heap corruption enabling potential code execution), but the UI:R constraint prevents wormable or automated mass exploitation. Priority for organizations using OpenImageIO in production pipelines (rendering farms, asset processing systems, media workflows) where malicious files could be introduced via file shares, email attachments, or third-party content. Lower priority for isolated systems or environments with strict file provenance controls.

Exploit ScenarioDerived

An attacker crafts a DPX image file with metadata specifying an extremely large pixel count (over 536 million pixels for ABGR format) that triggers signed integer overflow during buffer size calculation. The attacker delivers this file to a victim via email attachment, cloud storage share, or compromised content delivery network. When the victim opens the file in a visual effects application using vulnerable OpenImageIO (e.g., rendering software, image viewer, asset converter), the undersized heap buffer allocation occurs, followed by heap corruption when full image data is written. Depending on heap layout and memory protections, the attacker may achieve denial of service (application crash) or escalate to arbitrary code execution by corrupting adjacent heap structures.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – May 14, 2026

Heap buffer overflow in OpenImageIO 3.0.x (before 3.0.18.0) and 3.1.x (before 3.1.13.0) allows remote attackers to achieve denial of service or potentially arbitrary code execution via crafted DPX image files. The vulnerability stems from signed integer overflow in buffer size calculations within the DPX color converter, causing undersized heap allocations. Attack requires victim to open a malicious DPX file (user interaction required per CVSS UI:R). No public exploit code or active exploitation confirmed at time of analysis, though the technical details in the GitHub advisory provide sufficient detail for proof-of-concept development.

RemediationAI

Upgrade to OpenImageIO version 3.0.18.0 or later for the 3.0.x branch, or version 3.1.13.0 or later for the 3.1.x branch. Vendor-confirmed patched releases address the signed integer overflow in QueryRGBBufferSizeInternal() by correcting buffer size calculation logic. Download patched versions from the official Academy Software Foundation repository. If immediate patching is not feasible, implement file provenance controls to restrict DPX file processing to trusted sources only - block external DPX files at email gateways and enforce strict access controls on shared storage containing image assets. Consider sandboxing OpenImageIO-based applications using OS-level isolation (containers, restrictive AppArmor/SELinux profiles) to limit impact of potential exploitation. Note that DPX format restrictions may disrupt legitimate workflows requiring external vendor-supplied content; assess business impact before deployment. Monitor for abnormal application crashes when processing DPX files as potential exploitation indicator. Consult the GitHub advisory at https://github.com/AcademySoftwareFoundation/OpenImageIO/security/advisories/GHSA-cq46-hp4h-cvfr for additional technical details.

Affected VersionsENISA

OpenImageIO 3.1.4.0-beta, < 3.1.13.0
OpenImageIO < 3.0.18.0

Affected Packages

euvd openimageio fix: 3.0.18.0
euvd openimageio_3_1_4_0_beta fix: 3.1.13.0

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 a widely-used image I/O library in visual effects and animation pipelines, handling formats like DPX (Digital Picture Exchange). The vulnerability (CWE-190: Integer Overflow or Wraparound) occurs in QueryRGBBufferSizeInternal() within DPXColorConverter.cpp, which uses 32-bit signed integer arithmetic with intentional negative multipliers for certain color descriptors (kCbYCr uses pixels * -3 * bytes, kABGR uses pixels * -4 * bytes). Negative results signal to callers that no separate buffer allocation is needed. However, when pixel counts exceed approximately 536 million (for the -4 multiplier case), the multiplication wraps past INT_MIN to a small positive value. The caller in dpxinput.cpp misinterprets this as a valid buffer size requirement, allocates an undersized heap buffer via std::vector::resize(), then writes full image data via fread(), triggering classic heap buffer overflow. The affected CPE (cpe:2.3:a:academysoftwarefoundation:openimageio:*:*:*:*:*:*:*:*) indicates broad impact across any application integrating these library versions for image processing.

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 8.3 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:H
SUSE HIGH

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
May 14, 2026 - 21:32 EUVD
CVE Published
May 14, 2026 - 19:07 nvd
HIGH 8.3

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.18.0 and 3.1.13.0, a signed integer overflow in QueryRGBBufferSizeInternal() in DPXColorConverter.cpp leads to a heap-based out-of-bounds write when processing crafted DPX image files. The function computes buffer sizes using 32-bit signed integer arithmetic with negative multipliers (e.g., pixels * -3 * bytes for kCbYCr descriptors and pixels * -4 * bytes for kABGR descriptors), where a negative result is used as an in-band signal that no separate buffer is needed. When the pixel count is sufficiently large, the multiplication overflows INT_MIN and wraps to a small positive value. The caller in dpxinput.cpp interprets this positive value as a required buffer size, allocates an undersized heap buffer via m_decodebuf.resize(), and then writes the full image data into it via fread, resulting in a heap buffer overflow. An attacker can exploit this by crafting a DPX file that triggers the overflow, causing a denial of service (crash) or potentially arbitrary code execution through heap corruption in any application that reads pixel data using OpenImageIO. This vulnerability is fixed in 3.0.18.0 and 3.1.13.0.

Executive ViewAI

Why It Matters

OpenImageIO versions 3.0.x and 3.1.x contain a heap buffer overflow vulnerability that could allow attackers to crash applications or execute arbitrary code when users open malicious DPX image files. Organizations using OpenImageIO for image processing, visual effects, or content creation workflows face potential service disruption and data compromise until patching is available.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) Restrict DPX file uploads and processing to trusted internal sources only; (2) Disable or isolate OpenImageIO DPX color converter functionality if application architecture permits; (3) Implement file validation to reject DPX files from external or untrusted origins; (4) Run OpenImageIO processes with least-privilege accounts and resource limits to contain potential code execution impact; (5) Monitor for patch release from OpenImageIO project and establish expedited deployment process.

Threat Intelligence Overview

EPSS Score
0.0%
Top 88% exploitable
Data Quality
8 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub VulDB

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.0%
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
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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

Severity: High

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