Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious PST/OST/PAB with oversized 7c values_array_size
-
DeliveryDeliver file to victim or ingestion pipeline
-
Exploitlibpff parses unchecked column definition
-
ExecutionOut-of-bounds read of adjacent heap
-
ImpactHeap memory disclosed into record values or process crash
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires a victim to open or parse an attacker-crafted PST, OST or PAB file using an application linked against libpff version 0 through 20260926. The specific trigger is a 7c-type table column definition whose values_array_size field is larger than the remaining values-array buffer bytes (values_array_entry_size minus values_array_offset), which prior code did not validate before reading. Limiting factors: this is a local attack vector (AV:L) requiring user interaction (UI:P) - the attacker must get the malicious file processed; there is no network-service exposure and no privilege requirement. No special non-default configuration is needed beyond the application actually parsing table values from an untrusted mail-store file. Impact is bounded to limited heap information disclosure (adjacent memory read into record entry values) and availability loss (crash), with no integrity impact. |
| Impact | This is a moderate-severity, low-urgency issue whose signals are internally consistent rather than conflicting. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:H) correctly describes a local file-parsing bug: exploitation requires a victim to process an attacker-supplied PST, OST or PAB file (UI:P) with a vulnerable libpff build, not a network-reachable service, so despite PR:N (no authentication needed) it is not a remotely triggerable flaw. EPSS is very low (0.13%, 2nd percentile) and the vulnerability is NOT in CISA KEV, so there is no evidence of active or widespread exploitation - consistent with a niche forensic/email-parsing library rather than a mass-exploited target. The vuln.today decision label is 'this_month' (not act_now/emergency), matching the picture of a real but non-urgent bug. A public write-up reference exists (hackmd) alongside a GitHub issue, so some technical detail is public, but no SSVC automatable/technical-impact block was supplied in the input. Net assessment: a genuine memory-safety defect worth patching on a normal cycle, not a high-priority emergency; the primary real-world impact is a crash (VA:H) or limited heap-memory disclosure (VC:L) in tools that ingest untrusted mail-store files. |
| Exploit ScenarioDerived | An attacker crafts a malicious PST/OST/PAB file with a 7c-type table column definition whose values_array_size exceeds the remaining buffer, then delivers it to a victim (e.g., as an email export handed to a DFIR analyst or submitted to an automated forensic/ingestion pipeline). When an application built on libpff ≤20260926 parses the file via libpff_table_read_values_array, it reads adjacent heap memory into record-entry values or crashes. A public PoC reference exists (a hackmd write-up and GitHub issue); it is not verified as working exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Heap out-of-bounds read in libpff (libyal) versions 0 through 20260926 allows a crafted PST, OST or PAB mail-store file to cause the parsing application to copy adjacent heap memory into table record entry values or to crash. The flaw sits in libpff_table_read_values_array, where a 7c-type column definition's values_array_size is used without being checked against the bytes remaining in the values-array buffer. The attack is local and requires the victim to open or otherwise process a malicious file (AV:L, UI:R, PR:N), so impact is bounded to limited heap information disclosure plus availability loss from a crash; EPSS is 0.13% (2nd percentile), there is no CISA KEV listing, and a public technical write-up/PoC reference exists but is not verified as working exploit code.
RemediationAI
Apply the upstream fix in commit cb83eb38ffdbdfe2c69238fe7ce481ddc8513266 (https://github.com/libyal/libpff/commit/cb83eb38ffdbdfe2c69238fe7ce481ddc8513266), which adds the values_array_size versus remaining-buffer check in libpff_table_read_values_array and related hardening in libpff_table_read_6c_record_entries and libpff_block_tree_node_initialize; patch data indicates a vendor fix is available, but no tagged release version containing the commit is confirmed in the provided data, so distributors and embedding projects should rebuild against current libpff main or their vendor's patched build and confirm the commit is present. Verify the fix by tracking https://github.com/libyal/libpff/issues/172 and the vendor advisory. Until a patched build is deployed, the leverage point is the input file itself: avoid opening or batch-parsing PST, OST and PAB files of untrusted provenance with libpff-linked tools, and where processing is unavoidable run it in a disposable, low-privilege context so that the worst outcome is a crash rather than disclosure of heap contents into exported or logged record values; note that these measures trade functionality for risk reduction and no configuration flag disabling the affected table parsing is documented in the available sources.
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
libpff is the libyal library for parsing the Personal Folder File (PFF) family - PST, OST and PAB mail-store containers - and is consumed by forensic, mail-migration and indexing tools rather than exposed as a network service. The vulnerable path is table parsing: a table record (7c type) contains column definitions that describe where each value lives inside a values array, via values_array_offset and values_array_size. CWE-125 (out-of-bounds read) arises because prior code trusted values_array_size without confirming it fit within values_array_entry_size minus values_array_offset, so a file with an oversized size field makes the parser read past the end of the values-array buffer and place adjacent heap bytes into record entry values. The vendor commit cb83eb38ffdbdfe2c69238fe7ce481ddc8513266 adds the missing bounds check in libpff_table_read_values_array, tightens a related length comparison in libpff_table_read_6c_record_entries (changing a 16 * values_array_number overflow-prone multiply into a division-based check), and hardens libpff_block_tree_node_initialize against size arithmetic overflow in block-tree sizing. Only a file that is actually parsed far enough to reach table value handling triggers the condition; the flaw is a read, not a write, so no code execution primitive is described in the available sources.
Know when Libpff 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:H/SC:N/SI:N/SA:N
Local file parsing with no auth gives AV:L/PR:N but requires the victim to open a crafted file (UI:R); an OOB read yields limited heap disclosure (C:L) and crashes (A:H) with no integrity impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Libpff through 20260926 contains a heap out-of-bounds read vulnerability in libpff_table_read_values_array because a 7c column definition's values_array_size is not checked against remaining buffer bytes. Attackers can supply a crafted PST, OST or PAB file to make applications read adjacent heap memory into record entry values or crash.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
libpff_item_tree_create_node in libpff_item_tree.c in libpff before experimental-20180714 allows attackers to cause a de
Heap out-of-bounds reads in libpff through 20260926 allow attackers to crash applications (denial of service) and disclo
Heap out-of-bounds read in libpff through 20260926 can expose adjacent heap memory or crash applications such as pffexpo
The libpff_name_to_id_map_entry_read function in libpff_name_to_id_map.c in libyal libpff through 2018-04-28 allows remo
EUVD-2026-110484
GHSA-gcj6-823j-cwm9
NVD
CVE.org
EPSS
Exploit-DB