CVE-2026-89541
massInteger overflow in Linux kernel RPCSEC_GSS reply parsing (gss_unwrap_resp_priv)
The Linux kernel's SUNRPC/RPCSEC_GSS client code computes the reply bound check 'offset + opaque_len' entirely in 32-bit unsigned arithmetic, so a malicious reply declaring an opaque length near 0xffffffff wraps the sum to a small value, defeats the check, and passes an out-of-range end pointer into gss_unwrap(), reading kernel memory beyond the receive buffer. The flaw is triggered when a client with an active RPCSEC_GSS (e.g., NFS mounted with krb5i/krb5p) receives a crafted reply, which in practice requires an attacker to control, compromise, or spoof the RPC/NFS server the client is talking to. Because the malformed length is processed during unwrap handling, an attacker could gain out-of-bounds read of kernel memory (information disclosure) or crash the client (denial of service); CVSS 3.1 is rated 9.8 critical. The fix rewrites the checks into overflow-safe form — first rejecting offset > rcv_buf->len, then comparing opaque_len against rcv_buf->len - offset, and enforcing a minimum GSS_KRB5 token length floor mirroring the server-side check from commit 5b757c2e57a5. No public proof of concept or in-the-wild exploitation is known.
What to do: Apply distribution kernel updates that backport the hardened gss_unwrap_resp_priv() checks (look for the SUNRPC unwrap hardening commit in your vendor's changelog). Until patched, avoid krb5i/krb5p mounts against untrusted or internet-facing NFS servers and constrain clients to known servers via fixed addresses and Kerberos realm policy. Monitor NFS clients for kernel oops or crashes originating in net/sunrpc/auth_gss during reply processing.
| Linux kernel (net/sunrpc auth_gss RPCSEC_GSS client) | all kernel releases containing the vulnerable gss_unwrap_resp_priv() length check prior to the upstream fixing commit; the advisory does not specify exact versi |
Order-of-magnitude estimate by the model from install counts, market share and public scan data it knows; verify before quoting.
In the Linux kernel, the following vulnerability has been resolved: SUNRPC: harden gss_unwrap_resp_priv length checks gss_unwrap_resp_priv() validates the RPCSEC_GSS opaque length with offset = (u8 *)(p) - (u8 *)head->iov_base; if (offset + opaque_len > rcv_buf->len) goto unwrap_failed; maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, offset + opaque_len, rcv_buf); Both operands are u32 and the sum is computed in u32. A reply with opaque_len near 0xffffffff makes offset + opaque_len wrap to a small value that is below rcv_buf->len, so the bound check passes and gss_unwrap() is called with end rcv_buf->len) goto unwrap_failed; if (opaque_len > rcv_buf->len - offset) goto unwrap_failed; if (opaque_len < GSS_KRB5_TOK_HDR_LEN) goto unwrap_failed; The first guard makes the subtraction in the second guard unconditionally safe; offset is derived from a successful xdr_inline_decode() in the head kvec, so in practice it already satisfies the bound. The floor mirrors the server-side check added in commit 5b757c2e57a5 ("SUNRPC: svcauth_gss: enforce krb5 token minimum length").
- Vector
- CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
In the news0 stories
No ingested article mentions this CVE yet.