CVE-2026-99349 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
rxrpc: Fix lack of short-send handling in rxrpc_kernel_send_data()
Fix rxrpc_kernel_send_data() to loop around if it detects a short send. David Laight suggested doing it here rather than wrapping all the calls in loops. Further, remove the len argument and use the iterator count instead and return 0 on success, not the amount copied.
Note this is also a prerequisite for changing the way rxrpc_send_data() works to return a short send rather than an error if some data was buffered.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel vulnerability identified in the rxrpc subsystem addresses a critical flaw within the rxrpc_kernel_send_data function, specifically concerning the handling of partial or short sends during network transmission operations. The Remote Execution Protocol (RXRPC) is used for secure communication between clients and servers in distributed systems, such as those managed by the AFS file system. When data is transmitted over the network using this kernel interface, the underlying socket layer may not always transmit all requested bytes in a single operation due to various factors including buffer limits or flow control mechanisms. The original implementation failed to account for these scenarios where only a portion of the intended payload was successfully queued for transmission, leading to an immediate return that indicated success despite incomplete data delivery. This lack of retry logic meant that applications relying on this interface could erroneously believe their entire message had been sent when in fact significant portions remained untransmitted, potentially causing protocol desynchronization or silent data loss depending on the higher-level application logic.
The technical resolution involves modifying rxrpc_kernel_send_data to implement a loop structure that persists until all requested data has been processed by the iterator mechanism. By detecting short sends and looping back rather than returning prematurely, the function ensures atomicity in data transmission relative to its input parameters. Additionally, the fix refactors the API signature by removing the explicit length argument in favor of utilizing the iterator count directly. This change aligns with modern kernel programming practices that prefer iterators for managing buffer boundaries safely without risking integer overflows or misaligned memory accesses associated with manual length calculations. Furthermore, the return value semantics were adjusted to consistently return zero on success rather than returning the number of bytes copied. This standardization simplifies error handling for callers who expect a boolean-like status code where zero indicates no errors occurred, reducing ambiguity in application-level decision making regarding transmission outcomes.
From an operational impact perspective, this vulnerability primarily affects reliability and data integrity within systems utilizing RXRPC over unreliable network conditions or high-load scenarios where partial sends are frequent. Without the fix, applications might experience subtle bugs manifesting as incomplete file transfers, failed remote procedure calls, or state inconsistencies in distributed databases that depend on strict message boundaries enforced by the kernel layer. The absence of proper short-send handling violates fundamental expectations for stream-oriented socket interfaces which typically require callers to handle partial writes through retry loops anyway; offloading this responsibility incorrectly to the application without clear signaling creates a fragile integration point. By correcting this behavior, the kernel ensures that higher-level protocols receive accurate feedback about transmission progress, thereby preventing silent failures and enhancing overall system stability in enterprise environments relying on robust remote execution capabilities.
This issue maps directly to CWE-20 Improper Input Validation as it relates to incomplete processing of input data streams during I/O operations. It also aligns with ATT&CK techniques related to Defense Evasion through Obfuscated Files or Information if exploited by malicious actors attempting to hide the fact that certain commands were not fully executed on a target system, although its primary classification remains within reliability and correctness flaws rather than direct exploitation vectors for privilege escalation. Mitigation strategies involve applying the provided kernel patch which updates the rxrpc module logic to enforce complete data transmission loops. Administrators should ensure their systems are updated with the latest stable kernel versions containing this fix. For organizations unable to immediately update, implementing application-level retry mechanisms that check return values and re-send remaining buffers can serve as a temporary workaround, though relying on such workarounds is discouraged due to increased complexity and potential race conditions in concurrent environments. Regular auditing of network stack configurations and monitoring for anomalous transaction completions can help detect residual impacts from unpatched systems before they lead to significant service disruptions or data corruption events.