Skip to main content

libewf EUVDEUVD-2026-102286

| CVE-2026-111159 MEDIUM
Out-of-bounds Read (CWE-125)
2026-10-15 VulnCheck
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 .L01 image with oversized ea counts
  2. Delivery
    Deliver evidence file to forensic analyst
  3. Exploit
    Analyst opens image in libewf-based tool
  4. Execution
    Trigger heap OOB read in extended-attribute parser
  5. Impact
    Crash process or leak uninitialized heap memory

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 the target application to parse a crafted EWF logical-evidence file (.L01/.Lx01) using libewf, specifically reaching the extended-attribute ('ea') metadata path in libewf_lef_extended_attribute_read_data(), where UTF-16 name and value sizes are validated before being doubled. The limiting factors are significant: the attacker cannot reach the code remotely (AV:L) and must get a victim to open or process the malicious file (UI:P) - there is no automated or network-triggered path. No authentication is needed (PR:N), and default libewf behavior parses this metadata, so no special non-default configuration is required beyond the tool actually loading the attacker-controlled image. Realistic exposure is therefore limited to workflows that ingest untrusted or externally-supplied forensic images.

Impact

The CVSS 4.0 base score of 6.9 (Medium) is driven by local attack vector (AV:L), low complexity (AC:L), no privileges (PR:N) but required passive user interaction (UI:P), with impact concentrated in availability (VA:H, a crash) and only low confidentiality (VC:L, leak of uninitialized heap memory); integrity is unaffected. This is a file-parsing vulnerability, not a remotely reachable network flaw - exploitation requires a victim (typically a forensic analyst) to open or process an attacker-supplied .L01/.Lx01 evidence file, which meaningfully constrains real-world risk. Publicly available exploit code exists (hackmd write-up plus VulnCheck advisory), so the proof-of-concept signal is strong, but this is NOT the same as active exploitation: the CVE is not listed in CISA KEV and no EPSS score was provided in the input, so widespread opportunistic exploitation cannot be inferred. SSVC framing: exploitation is 'PoC', automatable is 'no' (requires per-victim file delivery and interaction), and technical impact is partial (crash/limited info leak rather than code execution). Net: this is a legitimate concern for digital-forensics practitioners who ingest untrusted evidence images, but it is a moderate, interaction-gated issue rather than a drop-everything internet-facing emergency. Note: the input provides only a CVSS 4.0 vector and no EPSS value - EPSS-based probability could not be weighed.

Exploit ScenarioDerived

An attacker crafts a malicious EWF logical evidence file (.L01/.Lx01) whose extended-attribute ('ea') metadata declares oversized UTF-16 name/value counts, then delivers it to a forensic analyst (for example, as a planted or submitted 'evidence' image). When the analyst parses the file with a libewf-based tool, libewf_lef_extended_attribute_read_data() reads past the heap buffer, crashing the application or disclosing uninitialized heap memory. A public proof-of-concept and write-up already exist, lowering the barrier to reproduction.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 15, 2026

Heap out-of-bounds read in libewf through 20260924 allows an attacker to crash an application or leak uninitialized heap memory by supplying a crafted .L01/.Lx01 logical-evidence image containing oversized 'ea' (extended attribute) metadata counts. The flaw is reachable only when the tool actually parses the attacker-controlled image: the CVSS 4.0 vector is local (AV:L) with passive user interaction (UI:P) and no privileges required (PR:N), and impact is concentrated in availability (VA:H, a crash) with only limited confidentiality (VC:L, memory disclosure). Public exploit code exists, but the vulnerability is not confirmed as actively exploited in CISA KEV.

RemediationAI

No vendor-released patch version is identified in the available data; the references point to the vulnerable source lines in libyal/libewf rather than to a fixed release, so patch status should be confirmed directly against the libyal/libewf repository and the VulnCheck advisory (https://www.vulncheck.com/advisories/libewf-through-20260924-heap-out-of-bounds-read-via-l01-extended-attribute-parsing) before assuming a fix exists. Until a patched build is confirmed, treat untrusted .L01/.Lx01 files as hostile input: only process EWF images from trusted, chain-of-custody-verified sources and reject or quarantine externally supplied images (effective but disrupts legitimate forensic intake of third-party evidence). Run any libewf-based parsing inside a sandboxed, low-privilege process with strict memory limits and crash monitoring so that an OOB read is contained and observed rather than exposing host memory (trade-off: adds latency and operational overhead, and a hard memory cap may still allow a crash-triggered denial of service). Where feasible, wrap or front-end the parser with a validating/memory-safe layer or an alternate reader that verifies 'ea' extended-attribute counts and sizes against the actual file length before handing data to libewf (trade-off: extra development effort and possible rejection of malformed-but-benign images). Patch references and the vulnerable code are at https://github.com/libyal/libewf/blob/d76fd0bb21601e2969bc88ffdaeb861023f6a5b2/libewf/libewf_lef_extended_attribute.c#L362-L408 and https://github.com/libyal/libewf/blob/d76fd0bb21601e2969bc88ffdaeb861023f6a5b2/libewf/libewf_lef_extended_attribute.c#L456-L560.

Affected VersionsENISA

libewf 0 ≤20260924

Affected Packages

euvd libewf 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

The issue is a CWE-125 out-of-bounds read in libewf, the open-source library from the libyal project used by forensic and imaging tools to read Expert Witness Format (EWF) files such as .L01/.Lx01 logical evidence images. Inside libewf_lef_extended_attribute_read_data() (see libewf_lef_extended_attribute.c around lines 362-408 and 456-560), the parser reads UTF-16 encoded extended-attribute names and values. The length fields for these UTF-16 strings are validated against the available data before the code doubles them to account for two bytes per UTF-16 code unit; because the bounds check is performed on the pre-doubled size, the subsequent doubled read can extend past the end of the allocated heap buffer. A crafted image with an inflated 'ea' (extended attribute) count or size triggers the mismatch, producing either a crash (high availability impact) or a read of uninitialized/adjacent heap memory that can be surfaced through the extended attributes (limited confidentiality impact). The affected component is identified by CPE cpe:2.3:a:libyal:libewf:*:*:*:*:*:*:*:*, and the underlying bug class is the classic integer/length-scaling validation error where a size check is applied to a unit count rather than to the final byte length. Code references are anchored to the libyal/libewf repository at commit d76fd0bb21601e2969bc88ffdaeb861023f6a5b2.

Know when Libewf 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

Triggered by parsing an attacker-supplied file (AV:L, UI:R), no auth (PR:N); heap info leak is C:L and the crash is 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

libewf through 20260924 contains a heap out-of-bounds read vulnerability in libewf_lef_extended_attribute_read_data() because UTF-16 name and value sizes are validated before being doubled. Attackers can supply a crafted .L01/.Lx01 file with oversized 'ea' metadata counts to crash the application or leak uninitialized heap memory through extended attributes.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Low
niche digital-forensics library, specialized practitioner footprint
Exploit
POC
Public exploit code exists
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 Yes
EPSS 0.1%
Patch available No
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
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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