Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure client to malicious NFS server
-
DeliveryReturn crafted ZDR-encoded response field
-
ExploitOversized length bypasses ignored maxsize
-
ExecutionWrite past preallocated buffer
-
ImpactCorrupt 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:H
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).
Primary rating from Vendor (mitre).
CVSS VectorVendor: mitre
Lifecycle Timeline
2DescriptionCVE.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
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.
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
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.
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.
EUVD-2026-97165
GHSA-vhww-3hg5-5f37
NVD
CVE.org
EPSS
VulDB
Exploit-DB