Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious ZIP-compressed TIFF
-
DeliveryDeliver file to victim or image pipeline
-
ExploitOpenImageIO decodes with multithreading enabled
-
ExecutionError path destroys captured objects early
-
PersistQueued worker tasks touch freed storage
-
ImpactUse-after-scope crash / DoS
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Expired pointer prevention
|
| Exploitation Conditions | Requires two specific conditions: (1) the target must process an attacker-crafted ZIP/Deflate-compressed TIFF, and (2) TIFF multithreading must be enabled so strip decompression runs asynchronously via task_set/uncompress_one_strip(). Exploitation is further limited by UI:R (a user or pipeline must open the malicious file), by AC:H (the crash depends on the decode taking the error path while worker tasks are still queued - a timing/race window), and by the affected version being prior to 3.1.16.0. Impact is confined to a crash (denial of service); there is no memory disclosure or code execution. |
| Impact | All signals converge on a low-to-moderate, availability-only issue. The vendor CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:N/A:H, base 5.3) describes a pure denial-of-service: no confidentiality or integrity impact, a high attack complexity, and required user interaction (a victim must process an attacker-supplied file). CWE-825 (use-after-scope / expired-pointer dereference) matches the root cause: in TIFFInput::read_native_scanlines() the task_set was declared before the ok flag and compressed_scratch buffer, so an early error-path return destroyed those captured objects before the task-set destructor waited on still-queued strip-decompression worker tasks - the workers then touch freed stack/heap storage and crash. No EPSS score, no CISA KEV listing, and no public POC were provided, so there is no evidence of active or automated exploitation; the outcome is a crash, not code execution. AC:H is well justified because the bug is a race that only manifests when the multithreaded decode path takes the error branch while async work is still outstanding, making reliable triggering nontrivial. One notable inconsistency: the vector uses AV:N, but the described trigger is a locally processed crafted TIFF, which is closer to AV:L unless OpenImageIO is embedded in a network-facing image-processing service - defenders should judge the vector by their own deployment. Net: a real correctness bug worth patching, but a low operational priority (best-case DoS, high complexity, needs user interaction, non-default multithreading path). |
| Exploit ScenarioDerived | An attacker crafts a malicious ZIP-compressed (Deflate) TIFF and gets a victim or an automated pipeline to open it with OpenImageIO while TIFF multithreading is enabled. The early error-path return destroys the ok flag and compressed_scratch buffer while worker threads are still decompressing strips, so those threads dereference freed storage and crash the host application. No public exploit code was provided, and the impact is limited to a denial of service. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 18, 2026
Denial of service in OpenImageIO prior to 3.1.16.0: processing a crafted ZIP/Deflate-compressed TIFF while TIFF multithreading is enabled can crash the image-reading process. The bug is an object destruction-order error in TIFFInput::read_native_scanlines(), where an error path returns before queued asynchronous strip-decompression tasks are joined, letting worker tasks touch stale stack and heap storage (use-after-scope). The assessed vector is CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:N/A:H - no privileges required, but a user or pipeline must open the malicious file (UI:R) and the crash depends on a narrow timing window (AC:H); impact is availability only, with no memory disclosure or code execution, and no public exploit identified at time of analysis.
RemediationAI
Upgrade to OpenImageIO 3.1.16.0 or later; this is the vendor-released patch that reorders the task_set declaration and changes the early return to a break so queued strip-decompression work is always joined before the captured ok and compressed_scratch objects go out of scope (see GHSA-v278-gpwr-r836, PR 5294, commit 31201c22df477b105b105c0dcfbf5d3d46db431b, and the v3.1.16.0 release tag). If immediate upgrade is not possible, the most direct compensating control is to disable TIFF multithreading in the decoding path, which removes the asynchronous worker tasks that can outlive the captured locals - at the cost of slower TIFF decompression throughput in multi-core pipelines. Because the trigger requires a crafted ZIP/Deflate-compressed TIFF to be opened by a user or pipeline, additional mitigations are to refuse or quarantine untrusted ZIP-compressed TIFF input at the application or ingest boundary, and to run TIFF decoding in a restricted, resource-limited subprocess or sandbox so that a crash cannot take down a larger host process - noting that these controls reduce functionality or throughput and do not address the underlying lifetime bug. TIFF multithreading is enabled by default in many OpenImageIO-based tools, so configuration review is needed before relying on a disable-multithreading workaround.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package 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 VFX/animation-oriented image I/O library and toolset, and the affected component is its TIFF reader (src/tiff.imageio/tiffinput.cpp), specifically TIFFInput::read_native_scanlines() and the strip-decompression helper uncompress_one_strip(). When TIFF multithreading is enabled, scanline decoding dispatches asynchronous strip decompression onto a thread pool wrapped in a task_set object; the captured state (an ok status flag and a compressed_scratch buffer) is stored in local objects in the same function scope. The root cause maps to CWE-825 (Expired Pointer Dereference): because task_set was declared before ok and compressed_scratch, the C++ destruction order destroyed those captured objects before ~task_set() performed its wait for queued work, so in-flight worker tasks dereferenced freed stack/heap storage. The flaw is only reached when decompression of a crafted ZIP-compressed TIFF takes the error path and the function returns early, bypassing tasks.wait(). The upstream fix reorders the declarations so task_set is constructed last (everything captured by the lambda outlives the wait) and replaces the early return with an explicit ok = false; break, ensuring control flow always falls through to the task-set wait. Affected product per CPE is cpe:2.3:a:academysoftwarefoundation:openimageio:*:*:*:*:*:*:*:* - i.e., all OpenImageIO versions before 3.1.16.0.
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
AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:N/A:H
Trigger is a locally opened crafted TIFF (AV:L), the crash is a timing-dependent async race (AC:H), needs a victim to open the file (UI:R), and only crashes the app (A:H, C/I:N).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
OpenImageIO is a toolset for reading, writing, and manipulating image files of any image file format relevant to VFX / animation. Prior to 3.1.16.0, a crafted ZIP-compressed TIFF processed with TIFF multithreading enabled can make TIFFInput::read_native_scanlines() return through an error path while asynchronous strip-decompression work remains queued. Because task_set is declared before ok and compressed_scratch, those captured objects are destroyed before the task-set destructor waits, allowing worker tasks to use stale stack and heap storage, resulting in a use-after-scope crash and denial of service. The affected implementation is identified by src/tiff.imageio/tiffinput.cpp, TIFFInput::read_native_scanlines(), task_set, ok, compressed_scratch, and uncompress_one_strip(), which define the relevant source path, functions, state, and trigger. This issue is fixed in 3.1.16.0.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Openimageio
View allBuffer Overflow vulnerability in OpenImageIO oiio v.2.4.12.0 allows a remote attacker to execute arbitrary code and caus
A code execution vulnerability exists in the DDS scanline parsing functionality of OpenImageIO Project OpenImageIO v2.4.
An out-of-bounds write vulnerability exists in the OpenImageIO::add_exif_item_to_spec functionality of OpenImageIO Proje
A heap based buffer overflow vulnerability exists in the PSD thumbnail resource parsing code of OpenImageIO 2.3.19.0. Ra
A heap based buffer overflow vulnerability exists in tile decoding code of TIFF image parser in OpenImageIO master-branc
A heap out-of-bounds write vulnerability exists in the way OpenImageIO v2.3.19.0 processes RLE encoded BMP images. Rated
A heap out of bounds read vulnerability exists in the handling of IPTC data while parsing TIFF images in OpenImageIO v2.
An issue in OpenImageIO oiio v.2.4.12.0 allows a remote attacker to execute arbitrary code and cause a denial of service
Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO
Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO
Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO
Multiple code execution vulnerabilities exist in the IFFOutput::close() functionality of OpenImageIO Project OpenImageIO
Same weakness CWE-825 – Expired Pointer Dereference
View allSame technique Denial Of Service
View allVendor StatusVendor
SUSE
Severity: Moderate| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
EUVD-2026-83126
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB