Skip to main content

Linux Kernel EUVDEUVD-2026-86233

| CVE-2026-93228 CRITICAL
2026-09-24 Linux GHSA-g29j-c673-5ccw
Critical
Disputed · 9.1 Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Reach NFS-over-RDMA server as peer
  2. Delivery
    Send Write/Reply chunk with segcount 0
  3. Exploit
    Bypass xdr_check_write_chunk range check
  4. Execution
    Zero-segment chunk linked onto parsed list
  5. Persist
    Trigger degenerate segment walk
  6. Impact
    Memory disclosure or server crash

Vulnerability Assessment

Exploitation Conditions

Requires a Linux NFS server configured with the RDMA transport (svcrdma) exporting over an RDMA fabric such as InfiniBand, RoCE, or iWARP - the vulnerable xdr_check_write_chunk()/pcl_alloc_write() path is only reachable in that configuration, which is not a default. The attacker must be positioned as an RDMA peer/client able to send Write or Reply chunks to the server (RFC 8166 RPC-over-RDMA), effectively requiring access to the RDMA network fabric. Exploitation is limited by: (1) the rarity of NFS-over-RDMA deployments; (2) the fact that an earlier patch in the same series already made pcl_for_each_segment() safe for ch_segcount==0, substantially reducing real impact on those trees; and (3) the need for RDMA-fabric reachability rather than arbitrary internet routing.

Impact

The input assigns CVSS 3.1 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H), which on its face reads as a critical, remotely-exploitable, unauthenticated flaw. However, multiple signals argue for materially lower real-world risk. First, the vulnerability lives in svcrdma - the NFS-over-RDMA server transport - which is only present when a Linux NFS server is configured to export over an RDMA fabric (InfiniBand/RoCE/iWARP); this is a niche deployment, not a default. Second, and most important, the description explicitly states the dangerous behavior was ALREADY neutralized by an earlier patch in the same series that made pcl_for_each_segment() safe for ch_segcount==0, so this specific commit is framed by the author as 'defense in depth' that keeps degenerate zero-segment chunks off the parsed lists - meaning the headline C:H/A:H impact largely reflects the pre-hardening memory-walk risk rather than what this change alone remediates. No EPSS score, no CISA KEV listing, and no public POC are present in the input, so there is no evidence of active or automatable exploitation. Note a mild conflict between the CVSS impact (C:H confidentiality) and the code narrative (defense-in-depth against a memory walk that no longer occurs), suggesting the score may overstate current risk; verify the exact reachable impact against the specific tree/version in use. Bottom line: high nominal CVSS but low practical priority except for the narrow population running NFS/RDMA servers exposed to untrusted RDMA peers.

Exploit ScenarioDerived

An attacker able to act as an RDMA peer to a Linux NFS-over-RDMA server sends a crafted Write or Reply chunk whose segcount field is zero, which slips past xdr_check_write_chunk()'s range check and gets linked onto rc_write_pcl/rc_reply_pcl as a zero-segment chunk. On kernels lacking the earlier pcl_for_each_segment() hardening this degenerate chunk could drive an out-of-bounds memory walk leading to disclosure or a server crash; on patched-series kernels the impact is largely contained, and no public exploit is identified at time of analysis.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.5% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 25, 2026

Linux kernel NFS/RDMA servers using svcrdma accept RPC-over-RDMA Write and Reply chunks whose segcount field is zero, because xdr_check_write_chunk() only rejects segcount values above rc_maxpages and xdr_inline_decode(stream, 0) succeeds without advancing the cursor, causing pcl_alloc_write() to link a struct svc_rdma_chunk with ch_segcount 0 onto the rc_write_pcl or rc_reply_pcl parsed-chunk lists even though RFC 8166 assigns no meaning to a chunk describing no remote buffer. The vulnerable path is reachable only on NFS servers configured with the RDMA transport over InfiniBand, RoCE, or iWARP, so an attacker must already be an RDMA peer able to send Write or Reply chunks to the server, and the independent assessment rates the realistic impact as availability-only (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) rather than the 9.1 input score, because an earlier patch in the same series already made pcl_for_each_segment() safe for ch_segcount 0. No public exploit code and no confirmed active exploitation are identified at time of analysis, and vendor-released patches are available in 6.12.111, 6.18.50, 7.2.4, and mainline 7.3-rc1.

RemediationAI

Apply the vendor-released patch by updating to a fixed kernel release: 6.12.111, 6.18.50, or 7.2.4 on stable branches, or mainline 7.3-rc1; the individual backport commits are https://git.kernel.org/stable/c/fe533ae1bed2ef2b3d54ee7ab410da1874ed3d4f, https://git.kernel.org/stable/c/a798714b58041e88716db3bf8fb03ae13eecd54a, https://git.kernel.org/stable/c/45dbdb2637b7fc5f1355b588780d2a7fb0516805, and https://git.kernel.org/stable/c/9808eb7656666acc7291bae9ab6b987bd16e47e0, and distributions carrying older trees should backport the zero-segcount floor in xdr_check_write_chunk() (which xdr_check_chunk_reply inherits) plus the pcl_alloc_write() list_add_tail() reordering. If patching cannot be done immediately, the highest-value compensating control is to stop exporting NFS through the RDMA transport and fall back to the TCP/RDMA-agnostic NFS transport (nfsd over TCP), which removes reachability of the vulnerable path entirely at the cost of RDMA performance for NFS traffic; alternatively, restrict the RDMA fabric so that only trusted, controlled peers can establish queue pairs and send Write or Reply chunks to the server (RDMA partition/VLAN isolation or pkey-based fabric segmentation), noting that this depends on network segmentation being correctly enforced and does not remove the defect. Deployments where an earlier patch in this series already made pcl_for_each_segment() safe for ch_segcount == 0 have materially reduced exposure, but the decode-boundary rejection should still be applied as defense in depth since the independent assessment treats the realistic outcome as an availability impact (crash/denial of service) on RDMA-configured servers rather than the confidentiality and integrity impact implied by the 9.1 input score; no public exploit code or confirmed active exploitation is known, so emergency out-of-band action is not mandated by exploitation evidence, and no vendor-released fix version should be assumed beyond those listed here.

Affected VersionsENISA

Linux 5.11
Linux 78147ca8b4a9b6cf0e597ddd6bf17959e08376c2 <9808eb7656666acc7291bae9ab6b987bd16e47e0
Linux patch: 0
Linux 78147ca8b4a9b6cf0e597ddd6bf17959e08376c2 <a798714b58041e88716db3bf8fb03ae13eecd54a
Linux 78147ca8b4a9b6cf0e597ddd6bf17959e08376c2 <45dbdb2637b7fc5f1355b588780d2a7fb0516805
Linux 78147ca8b4a9b6cf0e597ddd6bf17959e08376c2 <fe533ae1bed2ef2b3d54ee7ab410da1874ed3d4f
Linux patch: 6.12.111
Linux patch: 7.2.4
Linux patch: 7.3-rc1
Linux patch: 6.18.50

Affected Packages

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

svcrdma is the server-side implementation of RPC-over-RDMA (RFC 8166), which lets an NFS server receive RPC requests and reply using RDMA Write and Reply chunks instead of TCP streaming; each chunk carries a segcount describing how many remote buffer segments it references. In the vulnerable decode path, xdr_check_write_chunk() validates the incoming chunk header by comparing segcount against rc_maxpages, but a zero value passes that upper-bound-only range check, and the subsequent xdr_inline_decode(stream, 0) returns the current, non-NULL XDR cursor without moving it, so the function returns true and pcl_alloc_write() links the resulting svc_rdma_chunk (with ch_segcount 0) onto rc_write_pcl or rc_reply_pcl. xdr_check_reply_chunk() routes Reply chunks through the same function and inherits the identical flaw. Because an earlier patch in the same series already hardened pcl_for_each_segment() against ch_segcount 0, the remaining defect is a missing lower-bound validation at the decode boundary that is retained as defense in depth: it keeps degenerate zero-segment chunks off the parsed chunk lists so future consumers that walk ch_segments directly can never observe one, and it provides a simple zero-floor fix that is easier to backport than the macro change. The patch also reorders pcl_alloc_write() so that list_add_tail() occurs after the segment array is filled, ensuring partially populated chunks are never visible on the list during the fill loop. No CWE identifier was supplied with the record, but the root cause class is improper validation of an input length/segment-count field (a missing zero-value check in RFC 8166 chunk parsing). Affected CPE entries are cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:*.

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

Sources disagree (Medium–Critical)
Vendor (Linux) PRIMARY 9.1 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H
vuln.today AI 5.9 MEDIUM

Reachable only via RDMA-fabric peer against a non-default NFSoRDMA server (AC:H); unauthenticated peer input (PR:N); realistic residual impact is server crash/DoS (A:H), with confidentiality not clearly reachable post-hardening (C:N).

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE 5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
Red Hat 5.5 MEDIUM

vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Sep 25, 2026 - 05:23 NVD
9.1 (CRITICAL)
Patch available
Sep 24, 2026 - 17:18 EUVD
CVE Published
Sep 24, 2026 - 15:29 cve.org
CRITICAL 9.1
CVE Published
Sep 24, 2026 - 15:29 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

In the Linux kernel, the following vulnerability has been resolved:

svcrdma: Reject Write/Reply chunks with segcount 0

A peer can send a Write or Reply chunk whose segcount field is zero. xdr_check_write_chunk() only rejects segcount > rc_maxpages, so zero passes the range check, and xdr_inline_decode(stream, 0) returns the current (non-NULL) cursor without advancing. The function returns true and pcl_alloc_write() then links a struct svc_rdma_chunk with ch_segcount == 0 onto rc_write_pcl or rc_reply_pcl.

An earlier patch in this series made pcl_for_each_segment() safe for ch_segcount == 0, so this no longer drives the memory walk it used to. Rejecting the malformed frame at the decode boundary is still worthwhile as defense in depth: it keeps degenerate zero-segment chunks off the parsed chunk lists entirely, so any future consumer that walks ch_segments directly cannot observe one, and it makes the zero-floor easy to backport to trees where the macro change is more intrusive. RFC 8166 has no meaning for a Write/Reply chunk that describes no remote buffer, so no legitimate client is affected.

xdr_check_reply_chunk() funnels Reply chunks through xdr_check_write_chunk() and inherits the same rejection.

pcl_alloc_write() also links each chunk onto the parsed chunk list before filling its segment array. If a future change weakens the segcount-0 rejection, an incomplete chunk is visible to consumers during the fill loop. Reorder so that list_add_tail() follows the segment fill loop, ensuring only fully-populated chunks appear on the list.

Executive ViewAI

Why It Matters

A defect in the Linux kernel's NFS-over-RDMA server component can be triggered by an RDMA-connected peer and may disrupt or degrade file services on affected storage and application servers. Exposure is confined to NFS servers configured to serve over InfiniBand, RoCE, or iWARP, and the realistic impact is availability-only, with no identified effect on data confidentiality or integrity and no public exploit code identified at time of analysis. Because these servers typically underpin shared storage and application file access, unplanned outages could interrupt dependent business services, but the required RDMA-fabric position and specific configuration narrow the affected population.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.5%
Top 62% exploitable
Prevalence
Low
svcrdma NFS-over-RDMA server transport is a niche, non-default kernel feature
Data Quality
4 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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Yes
Human Impact
Medium

Priority Score

46
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +46
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

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

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
openSUSE Tumbleweed Fixed
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected

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