EUVD-2026-115912
GHSA-j35h-4545-xh77
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft HDF5 file with truncated scaleoffset chunk
-
DeliveryDeliver file to victim user or application
-
ExploitVictim reads the affected dataset
-
ExecutionFilter decodes uninitialized heap remainder
-
ImpactProcess memory disclosed as dataset data
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Variable initialization
|
| Exploitation Conditions | Exploitation requires that the targeted dataset use the HDF5 scaleoffset filter and that the victim open and read that dataset from an attacker-supplied HDF5 file in which the filtered chunk record is truncated (fewer bytes stored than the chunk's declared/unfiltered size); H5D__chunk_lock() sizes the chunk buffer to the larger of stored and unfiltered sizes and fills only the stored bytes, so the truncated chunk passes the allocation-based bounds check and the uninitialized remainder is decompressed and returned. Limiting factors that reduce real-world risk: the vector is local (the attacker must get the file to the victim, not reach it over the network), it requires user/application interaction to read the dataset, the affected dataset must specifically employ the scaleoffset filter, and the impact is limited to confidentiality (heap memory disclosure) with no code execution, data modification, or crash. Because the reads stay within the allocation, AddressSanitizer does not detect the issue, which may delay discovery in testing. |
| Impact | This is a low-priority issue, and the signals are largely consistent on that. The supplied CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:N) yields a base score of 1.9, and vuln.today assigns a 'monitor' decision label - the two agree that this is not urgent. The vector is local (AV:L) and requires passive user interaction (UI:P): a victim must read a crafted HDF5 file, so there is no remote network exposure. Impact is confined to low confidentiality (VC:L) - disclosure of unrelated heap bytes returned as dataset values - with no integrity or availability impact, matching CWE-908 (use of uninitialized resource). No CISA KEV listing and no EPSS score are present in the input, so there is no signal of active or probable exploitation. The one conflicting signal is the CVSS exploit-maturity flag E:P (Proof-of-Concept): it claims a PoC exists, yet the only reference supplied is the vendor fix PR (HDFGroup/hdf5#6585), not an exploit or PoC reference - so the E:P claim cannot be verified from the provided data and should be confirmed with the source. Overall this is a genuinely high-CVSS-irrelevant case: it is a real memory-disclosure bug but low real-world risk given local vector, required user interaction, limited (info-disclosure-only) impact, and the fact that it is an incomplete-fix follow-up to CVE-2026-19029. |
| Exploit ScenarioDerived | An attacker crafts an HDF5 file containing a dataset whose scaleoffset-filtered chunk is truncated (shorter than the bytes the chunk header claims). When a user or application opens the file and reads that dataset, H5Z__filter_scaleoffset() decodes the uninitialized remainder of the over-sized chunk allocation and returns unrelated heap contents to the caller, disclosing process memory. The input references a fix PR but no working exploit code; the CVSS vector's E:P flag asserts a PoC, which is not verified against any supplied PoC reference. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
HDF5 through 2.2.0 discloses process heap memory when an application opens and reads a dataset that uses the scaleoffset filter from a crafted file whose filtered chunk record is truncated. The decode path in H5Z__filter_scaleoffset() validates reads against the allocated size of the chunk buffer instead of the number of bytes actually stored, and because H5D__chunk_lock() sizes that buffer to the larger of the stored and unfiltered chunk sizes while filling only the stored bytes, the truncated chunk passes the bounds check and the uninitialized remainder is decompressed and returned as dataset data. The vulnerability is local (CVSS:3.1/AV:L/AC:L/PR:N/UI:R), requires the victim to open and read the crafted file, and is limited to confidentiality impact with no code execution, modification, or crash; an upstream fix exists in PR 6585 but no released patched version is confirmed, and no public exploit has been identified.
RemediationAI
No vendor-released patched version is confirmed at time of analysis; the fix exists as upstream PR/commit https://github.com/HDFGroup/hdf5/pull/6585 and a released version containing it should be tracked and adopted once published, so treat current HDF5 builds through 2.2.0 as unpatched for this issue. Because exploitability depends on the scaleoffset filter being applied to the dataset being read, deployments that must consume untrusted HDF5 files before a patched release can reduce exposure by avoiding the scaleoffset filter for datasets exchanged with untrusted parties and by validating chunk lengths against the declared unfiltered size before decoding - noting that this requires application-level changes and does not protect files already written with the filter. Running decoding of untrusted files in a sandboxed or memory-isolated process limits the confidentiality impact of leaked heap contents, at the cost of performance and operational complexity. AddressSanitizer will not detect this condition, so test suites relying on it should add explicit checks for truncated chunk records such as those added in test/direct_chunk.c. Upstream also hardened the szip and fletcher32 filters in the same change, so applying the full commit is preferable to a narrow scaleoffset-only fix.
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
HDF5 stores large datasets as chunks, and each chunk may pass through a filter pipeline on write and read. The scaleoffset filter (src/H5Zscaleoffset.c) prepends a 21-byte parameter block containing minbits, a minimum-value size field and the minimum value itself, and the decode path in H5Z__filter_scaleoffset() must parse that header before decompressing the payload. The root cause class is CWE-908 (use of uninitialized resource): the code checked the header reads against *buf_size, the allocated size of the chunk buffer, rather than nbytes, the number of bytes actually read from the file. H5D__chunk_lock() deliberately allocates the filtered chunk buffer to hold the larger of the stored (filtered) chunk size and the unfiltered chunk size, but fills only the stored bytes, so a truncated chunk leaves uninitialized heap past the valid data yet still satisfies the allocation-based bound. The filter then decompresses out of that uninitialized region and hands unrelated heap contents back to the caller as dataset values. Because every read stays inside the allocation, AddressSanitizer does not flag it, which is why the flaw survived earlier fixes. The same incomplete-fix pattern affected the szip filter, which subtracted its fixed 4-byte uncompressed-length header from the chunk length without first verifying the chunk was at least that long (allowing a size_t underflow and reads past the chunk buffer), and the fletcher32 filter, which accepted a chunk holding only its 4-byte checksum. The upstream PR 6585 adds explicit minimum-length checks (nbytes < 5 for the scaleoffset fields, nbytes <= SZIP_HEADER_LEN and nbytes <= FLETCHER_LEN for the others) and converts the scaleoffset bounds checks to use nbytes instead of *buf_size. This is an incomplete fix for CVE-2026-19029.
Know when Scale Offset Filter 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
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N/E:P
Triggered only when a victim reads a crafted file, so AV:L and UI:R with PR:N; the flaw leaks heap bytes into returned data, giving C:L with no integrity or availability impact.
Primary rating from Vendor (HDFG).
CVSS VectorVendor: HDFG
Lifecycle Timeline
1DescriptionCVE.org
HDF5 through 2.2.0 contains an uninitialized memory read vulnerability in H5Z__filter_scaleoffset() in src/H5Zscaleoffset.c. The decode path validates reads against the allocated size of the chunk buffer rather than the number of bytes actually read from the file. Because H5D__chunk_lock() deliberately sizes filtered chunk buffers to the larger of the stored and unfiltered chunk sizes and fills only the stored bytes, a truncated chunk passes these bounds checks and is decompressed from the uninitialized remainder of the allocation. Unrelated heap contents are then returned to the caller as dataset data. Because the reads remain within the allocation, the issue is not detected by AddressSanitizer. An attacker who can get a user or application to read a dataset from a crafted HDF5 file can cause disclosure of process memory. This issue exists because of an incomplete fix for CVE-2026-19029.
Threat Intelligence Overview
NVD
CVE.org
Vulnrichment
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Exploit-DB