Skip to main content

libnfs EUVDEUVD-2026-97165

| CVE-2026-108985 HIGH
Out-of-bounds Write (CWE-787)
2026-10-12 cve@mitre.org GHSA-vhww-3hg5-5f37
7.1
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Lure client to malicious NFS server
  2. Delivery
    Return crafted ZDR-encoded response field
  3. Exploit
    Oversized length bypasses ignored maxsize
  4. Execution
    Write past preallocated buffer
  5. Impact
    Corrupt memory and crash client

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

The victim must run an application linked against libnfs (through 6.0.2, before commit 7613236464317bee2d9636f087f995148de4db27) and connect to an attacker-controlled or MITM'd NFS/RPC server; exploitation requires that the caller passed a preallocated, fixed-size buffer with a non-zero, non-~0 maxsize into libnfs_zdr_bytes(), libnfs_zdr_string(), or libnfs_zdr_array(), because those decoders ignored maxsize and allowed the wire-declared length to exceed it (protocol limits such as NFS4_FHSIZE and NFS4_OPAQUE_LIMIT were skipped the same way). Limiting factors: exploitation is client-side and needs the victim to initiate/complete the connection (UI:R), the attacker must control the server side of the RPC exchange, and fields where rpcgen emits maxsize 0 or ~0 (unbounded) are not affected since those remain intentionally unlimited.

Impact

CVSS 3.1 base score is 7.1 (HIGH) with vector AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:H, which is internally consistent with a client-side memory-corruption flaw: an unauthenticated remote party (a malicious or compromised NFS server) can trigger it, but UI:R means a victim client must first initiate/complete a connection to that server, so it is not a self-propagating, drive-by remote bug. The impact profile (C:N, I:L, A:H) points to crashes/denial of service as the most reliable outcome from the out-of-bounds write (CWE-787), with code execution being theoretically possible but not demonstrated. No EPSS score, SSVC decision, or CISA KEV status was provided in the input, and there is no public exploit identified - the only linked artifact is the upstream fix commit, which adds a regression test rather than a weaponized PoC. Net: this is a legitimate issue to patch for anyone embedding libnfs, but the required attacker position (control of, or MITM over, the NFS server the victim talks to) plus UI:R make it a moderate, situational priority rather than a mass-exploitable emergency. Missing signal to note explicitly: EPSS/KEV data is absent, so widespread-exploitation likelihood could not be quantified.

Exploit ScenarioDerived

An attacker stands up a malicious NFS server, or man-in-the-middles an existing one, and waits for a libnfs-based client to connect. When the client issues an RPC, the server returns a ZDR-encoded bytes/string/array field whose declared length exceeds the maxsize the caller reserved for its preallocated buffer; because the decoders ignore maxsize, the oversized payload is written past the end of that buffer, corrupting adjacent memory and typically crashing the client. No public exploit exists, though the fix commit ships a test harness (prog_zdr_maxsize.c) that deterministically reproduces the overflow past a preallocated destination.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 12, 2026

Out-of-bounds write in libnfs through 6.0.2 lets an attacker-controlled or man-in-the-middled NFS/RPC server corrupt memory in a client application linked against the library: the ZDR decoders libnfs_zdr_bytes(), libnfs_zdr_string() and libnfs_zdr_array() do not honour the caller-supplied maxsize, so a wire-declared length larger than the caller's preallocated buffer is accepted and copied past its end. The assessed CVSS 3.1 base score is 7.1 (High) with vector AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:H, i.e. an unauthenticated remote server can trigger it but the victim must first connect to that server (UI:R), and impact is limited to integrity plus high availability loss rather than data disclosure. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and the flaw only affects callers that pass a non-zero, non-~0 maxsize with their own fixed-size storage, since zero/0xFFFFFFFF lengths remain intentionally unbounded.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed. The corrective change is commit 7613236464317bee2d9636f087f995148de4db27 in sahlberg/libnfs (https://github.com/sahlberg/libnfs/commit/7613236464317bee2d9636f087f995148de4db27), which adds the libnfs_zdr_size_ok() bounds check to the bytes, string and array decoders and a regression test (tests/prog_zdr_maxsize.c); apply that commit, cherry-pick it onto the 6.0.2 tree, or consume a later libnfs release that contains it (no specific fixed version number is asserted here because none is given in the supplied data). Because the patch changes semantics by turning positive maxsize values into hard limits, validate any in-tree caller that relied on over-long fields being accepted, and note that zero or ~(uint32_t)0 still means 'unbounded' by design. Until the fix is deployed, the most effective compensating control is to shrink the attack surface on the client side: only mount or query NFS servers that are trusted and reachable over a protected path, since the attacker must control the server end of the RPC exchange and a MITM positioning is sufficient; enforce RPCSEC_GSS/Kerberos, IPsec or TLS tunnelling and strict export/host allow-listing so that an untrusted host cannot answer RPC traffic, accepting that this does not remove the underlying bug and that legacy unauthenticated NFSv3 deployments lose convenience. Auditing and, if feasible, temporarily avoiding the affected API pattern - passing a bounded preallocated buffer with a positive maxsize into libnfs_zdr_bytes(), libnfs_zdr_string() or libnfs_zdr_array() - removes exposure for custom callers at the cost of reworking their decode logic. Generic memory-hardening (ASLR, heap canaries, hardened allocators) can make exploitation less reliable but must not be treated as a fix.

Affected VersionsENISA

libnfs 0 <7613236464317bee2d9636f087f995148de4db27
libnfs 0 ≤6.0.2

Affected Packages

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

libnfs ships its own XDR (external data representation) marshalling layer, ZDR, implemented in lib/libnfs-zdr.c, which encodes and decodes the RPC/NFS wire format for NFSv3 and NFSv4 clients. The vulnerability is CWE-787 (out-of-bounds write) arising from a missing bounds check: the decode paths of libnfs_zdr_bytes(), libnfs_zdr_string() and libnfs_zdr_array() read a length field off the wire and copy that many bytes into storage supplied by the caller, but never compared the declared length against the maxsize parameter the caller passed to describe that storage's capacity. As a result, protocol-enforced caps such as NFS4_FHSIZE (128 bytes) and NFS4_OPAQUE_LIMIT (1024 bytes) were skipped the same way, and any application linking libnfs that handed the decoders a preallocated buffer with a positive, non-~0 maxsize could be written past the end of that buffer by a malicious or compromised server. The fix commit 7613236464317bee2d9636f087f995148de4db27 introduces a libnfs_zdr_size_ok() helper that treats positive maxsize values as hard limits on both ZDR_ENCODE and ZDR_DECODE, while preserving rpcgen semantics where maxsize 0 or ~(uint32_t)0 mean 'unbounded' (the AUTH credential/verifier paths pass a live length and a zeroed object legitimately has length zero). A new regression test, tests/prog_zdr_maxsize.c (wired into both CMakeLists.txt and Makefile.am), exercises the preallocated-buffer case with canary bytes to confirm no over-write occurs. No CPE strings were provided with this report, so affected identification rests on the library name and the 'through 6.0.2' version statement.

Know when the next one hits your stack

  • 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 (mitre) PRIMARY 7.1 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:H
vuln.today AI 7.1 HIGH

A malicious server needs no auth (PR:N) but the victim client must connect (UI:R); the out-of-bounds write mainly crashes the client (A:H, I:L) with no data disclosure (C:N).

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

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
None
Integrity
Low
Availability
High

Lifecycle Timeline

2
Patch available
Oct 12, 2026 - 04:15 EUVD
CVE Published
Oct 12, 2026 - 03:17 cve.org
HIGH 7.1

DescriptionCVE.org

ZDR decoding in libnfs through 6.0.2 before 7613236 has an out-of-bounds write related to lib/libnfs-zdr.c with libnfs_zdr_bytes(), libnfs_zdr_string(), and libnfs_zdr_array(). The caller-supplied maxsize value is not honored.

Executive ViewAI

Why It Matters

A memory-corruption flaw in libnfs (versions through 6.0.2) affects every application that embeds the library to mount NFS shares - backing up, media indexing, virtualization, and orchestration tooling among them. An attacker who controls or intercepts the server the client connects to can crash, and potentially corrupt, the client process, turning availability of dependent workloads into the primary exposure. Because the victim must initiate a connection to a hostile or man-in-the-middled server and no vendor patch or public exploit currently exists, this is a contained but unpatched risk that deserves inventory and network-level mitigation rather than emergency action.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: restrict NFS/RPC mounts to trusted internal servers only (the flaw requires the client to connect to an attacker-controlled or man-in-the-middled server); enforce authenticated, integrity-protected mounts (e.g., Kerberos krb5p) to prevent length-field tampering; where feasible, configure callers to use the unbounded zero/0xFFFFFFFF path; and apply process crash supervision, resource limits, and restart alerting to limit availability loss.

Threat Intelligence Overview

EPSS Score
0.2%
Top 93% exploitable
Prevalence
Medium
userspace NFS client library embedded in qemu, media players, and tools
Social Media
4
Sightings
Data Quality
6 sources
Confidence: High

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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
Medium

Priority Score

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

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

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