Skip to main content

libpff EUVDEUVD-2026-110484

| CVE-2026-116736 MEDIUM
Out-of-bounds Read (CWE-125)
2026-10-26 VulnCheck GHSA-gcj6-823j-cwm9
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious PST/OST/PAB with oversized 7c values_array_size
  2. Delivery
    Deliver file to victim or ingestion pipeline
  3. Exploit
    libpff parses unchecked column definition
  4. Execution
    Out-of-bounds read of adjacent heap
  5. Impact
    Heap 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

libpff 0 ≤20260926

Affected Packages

euvd libpff no fix

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

Vendor (VulnCheck) PRIMARY 6.9 MEDIUM
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
vuln.today AI 6.1 MEDIUM

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.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Low
niche forensic/DFIR library for PST/OST parsing, narrow deployment domain
Data Quality
5 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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