CVE-2026-99388 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

smb: smbdirect: fix buffer length underflow in RDMA transfers

When a remote buffer descriptor is larger than the remaining local buffer, smbdirect_connection_rdma_xmit() clamps its length and sets buf_len to zero. The common accounting code then subtracts the clamped length from buf_len, causing it to underflow. If another descriptor follows, the loop processes it with a wrapped remaining length and includes memory beyond the local buffer in the RDMA transfer.

A client can trigger an out-of-bounds kernel write with an SMB WRITE request, or an out-of-bounds kernel read with an SMB READ request, by supplying multiple RDMA buffer descriptors with an oversized descriptor before the last one.

Remove the premature assignment to buf_len. Subtracting the clamped length already consumes the remaining buffer, so the next iteration stops and only descriptors within the local buffer are used to build work requests.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/19/2026

The vulnerability identified in the Linux kernel's SMB Direct implementation involves a critical integer underflow condition during Remote Direct Memory Access (RDMA) data transfers. This flaw resides specifically within the smbdirect_connection_rdma_xmit function, which is responsible for handling RDMA operations for Server Message Block over TCP connections that utilize direct memory access capabilities. The core issue arises from an incorrect sequence of arithmetic operations when processing multiple buffer descriptors provided by a remote peer. When a remote buffer descriptor specifies a length that exceeds the remaining space in the local kernel buffer, the code correctly clamps this length to fit within available bounds and subsequently sets the buf_len variable to zero to indicate no further data can be transferred from that specific segment. However, the subsequent accounting logic erroneously subtracts this already-clamped length from buf_len. Since buf_len was set to zero or a small positive value representing remaining capacity, subtracting even a clamped positive length results in an integer underflow, wrapping the unsigned variable around to a very large maximum value.

This arithmetic error has severe security implications because it fundamentally breaks the boundary checks that protect kernel memory from unauthorized access. With buf_len wrapped to a massive value due to the underflow, the subsequent iteration of the descriptor processing loop believes there is ample space remaining in the local buffer for additional data transfers. Consequently, if another RDMA buffer descriptor follows the oversized one in the request structure, the system proceeds to include this next descriptor in the work requests sent to the hardware. This leads to an out-of-bounds kernel write when handling SMB WRITE operations or an out-of-bounds kernel read during SMB READ operations. An attacker can exploit this by crafting a malicious SMB packet containing multiple RDMA buffer descriptors where at least one descriptor is oversized relative to the remaining local buffer space, thereby triggering the underflow and allowing access to arbitrary kernel memory regions beyond the intended allocation boundaries.

From a classification perspective, this vulnerability aligns with CWE-190 Integer Overflow or Wraparound, as the root cause is the improper handling of arithmetic operations on unsigned integers leading to unexpected large values. Furthermore, because it allows an unauthenticated remote attacker to read from or write to kernel memory via network requests, it falls under CWE-787 Out-of-bounds Write and CWE-125 Out-of-bounds Read respectively. In terms of the MITRE ATT&CK framework, this vulnerability facilitates techniques associated with T1068 Exploitation for Privilege Escalation or T1041 Exfiltration Over C2 Channel if used to leak sensitive kernel data. The attack vector is classified as Network-based and requires no user interaction beyond sending a crafted network packet, making it particularly dangerous in environments where SMB services are exposed to untrusted networks.

The operational impact of this vulnerability includes potential system crashes due to memory corruption, leakage of sensitive information stored within the kernel address space such as credentials or encryption keys, and potentially arbitrary code execution if an attacker can control the data written via the out-of-bounds write primitive. The fix implemented removes the premature assignment that sets buf_len to zero before the subtraction occurs. By allowing the accounting logic to subtract the clamped length directly from the actual remaining buffer size without resetting it first, the loop correctly detects when the local buffer is exhausted and stops processing further descriptors. This ensures that only descriptors fitting within the allocated local memory are used to build RDMA work requests, effectively closing the gap that allowed out-of-bounds access. System administrators should ensure their Linux kernels are updated with this patch applied to mitigate the risk of remote exploitation via SMB Direct connections.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00224

KEV

no

Activities

very low

Sources

Interested in the pricing of exploits?

See the underground prices here!