CVE-2026-64269
Analyzed Analyzed - Analysis Complete

Buffer Overflow in Linux Kernel RDMA/rtrs-srv

Vulnerability report for CVE-2026-64269, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-07-25

Last updated on: 2026-08-13

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: RDMA/rtrs-srv: Bound RDMA-Write length to chunk size in rdma_write_sg When the server answers an RTRS READ, rdma_write_sg() builds the source scatter/gather entry for the IB_WR_RDMA_WRITE that returns data to the peer. Its length is taken directly from the wire descriptor: plist->length = le32_to_cpu(id->rd_msg->desc[0].len); rd_msg points into the chunk buffer that the remote peer filled via RDMA-WRITE-WITH-IMM (rtrs_srv_rdma_done() -> process_io_req() -> process_read()), so desc[0].len is attacker-controlled and, before this change, was only rejected when zero. The source address is the fixed chunk start (dma_addr[msg_id]) and the source lkey is the PD-wide local_dma_lkey, which is not tied to the chunk's MR mapping, so the verbs layer does not constrain the transfer length to max_chunk_size. msg_id and off are bounded against queue_depth and max_chunk_size in rtrs_srv_rdma_done(), but desc[0].len is a separate field that was not checked against the chunk size. A peer that advertises desc[0].len larger than max_chunk_size can make the posted RDMA write read past the chunk's mapped region. The resulting behaviour depends on the IOMMU configuration: with no IOMMU or in passthrough mode the read may extend into memory adjacent to the chunk and be returned to the peer, which can disclose host memory; with a translating IOMMU the out-of-range access is expected to fault and abort the connection. In either case the transfer exceeds what the protocol permits and is driven by a remote peer. Reject a descriptor length above max_chunk_size, mirroring the existing off >= max_chunk_size bound in rtrs_srv_rdma_done(). Legitimate clients do not exceed it: the client sets desc[0].len to its MR length, which is capped at the negotiated max_io_size (max_chunk_size - MAX_HDR_SIZE).

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-07-25
Last Modified
2026-08-13
Generated
2026-08-14
AI Q&A
2026-07-25
EPSS Evaluated
2026-08-13
NVD
EUVD

Affected Vendors & Products

Showing 6 associated CPEs
Vendor Product Version / Range
linux linux_kernel From 5.16 (inc) to 6.1.178 (exc)
linux linux_kernel From 6.2 (inc) to 6.6.145 (exc)
linux linux_kernel From 6.7 (inc) to 6.12.96 (exc)
linux linux_kernel From 6.13 (inc) to 6.18.39 (exc)
linux linux_kernel From 6.19 (inc) to 7.1.4 (exc)
linux linux_kernel From 5.8 (inc) to 5.15.212 (exc)

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This vulnerability in the Linux kernel involves a flaw in the RDMA/rtrs-srv subsystem where an attacker-controlled length field in a wire descriptor is not properly validated. When processing an RTRS READ request, the server uses this length to build an RDMA write operation without checking if it exceeds the chunk size. This can lead to out-of-bounds memory reads, potentially exposing sensitive host memory or causing connection aborts depending on IOMMU configuration.

Detection Guidance

This vulnerability affects the Linux kernel's RDMA/rtrs-srv component. Detection requires checking kernel versions and RDMA configurations. Use commands like 'uname -a' to verify kernel version and 'lsmod | grep rtrs' to check if the vulnerable module is loaded.

Impact Analysis

If exploited, this vulnerability could allow a remote attacker to read memory adjacent to a chunk buffer, potentially leaking sensitive data. The impact depends on system configuration: without IOMMU, memory disclosure may occur; with translating IOMMU, the connection may abort. Legitimate clients are unaffected as they respect the max_chunk_size limit.

Compliance Impact

This vulnerability could potentially lead to unauthorized disclosure of sensitive data, which may violate compliance requirements under GDPR (General Data Protection Regulation) and HIPAA (Health Insurance Portability and Accountability Act). If exploited, it may allow an attacker to read memory adjacent to the chunk, potentially exposing personal or health-related information.

Mitigation Strategies

Apply the latest kernel security updates to patch the vulnerability. If immediate patching is not possible, disable the RDMA/rtrs-srv functionality by unloading the module with 'rmmod rtrs_srv' or blacklisting it.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-64269. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart