CVE-2026-99590 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
ceph: clamp the inline data length in ceph_fill_inline_data()
The MDS decides how much inline data to attach to a reply, and the client parses inline_len without any upper bound: ceph_decode_need() only verifies that the message actually carries that many bytes. ceph_fill_inline_data() then copies the data into a single folio with no length check, so a malicious or buggy MDS returning more inline data than the folio can hold writes past its end.
Clamp the length to folio_size() so both callers, handle_cap_grant() and fill_inode(), are covered.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 11/21/2026
The Linux kernel's Ceph distributed file system implementation contains a critical buffer overflow vulnerability within the ceph_fill_inline_data function, which is responsible for handling inline data attached to metadata replies from the Metadata Server or MDS. This flaw stems from an insufficient validation of input parameters during the parsing phase of incoming network messages. Specifically, when the client receives a reply containing inline data, it relies on the length field provided by the sender without enforcing any upper bound relative to the local buffer capacity. The existing check using ceph_decode_need only verifies that the message payload contains at least enough bytes to satisfy the declared length but fails to ensure that this length is compatible with the destination memory structure's limits.
The technical root cause lies in the absence of a bounds check before copying data into a folio, which represents a contiguous set of pages used by the kernel for managing file content and metadata. When ceph_fill_inline_data executes, it proceeds to copy the specified amount of inline data directly into this single folio without verifying whether the requested length exceeds the physical size of the folio itself. This lack of validation allows a malicious or buggy MDS to craft a response with an artificially inflated inline_len value. Upon processing such a crafted packet, the kernel performs a memory write operation that extends beyond the allocated boundaries of the target folio, resulting in a heap-based buffer overflow.
This vulnerability poses significant operational risks as it can lead to arbitrary code execution or system crashes depending on how the overwritten memory is utilized by subsequent operations. Since the affected function is invoked during critical path operations such as handling capability grants and filling inode structures via handle_cap_grant and fill_inode, an attacker could potentially exploit this flaw during routine file access or metadata updates. The overflow corrupts adjacent kernel data structures, which may allow for privilege escalation if executed in a context with elevated permissions or cause denial of service through kernel panic due to memory corruption.
The resolution involves clamping the inline data length to match folio_size before performing any copy operations. By enforcing this upper bound check within ceph_fill_inline_data, both callers handle_cap_grant and fill_inode are protected from receiving oversized lengths that could trigger out-of-bounds writes. This fix ensures that even if a remote MDS attempts to send excessive inline data, the kernel will truncate the operation to fit safely within the allocated memory space, thereby preventing buffer overflow conditions.
From a classification perspective, this vulnerability aligns with CWE-120 Buffer Copy without Checking Size of Input Classic and CWE-787 Out-of-bounds Write in terms of its technical nature as an improper bounds check leading to memory corruption. In the context of adversarial tactics, it relates to ATT&CK technique T1564 Hidden Elements where attackers might hide malicious payloads within seemingly normal protocol fields like inline data lengths. Mitigation strategies include applying the upstream kernel patch that enforces strict length validation against folio boundaries and ensuring that all network-facing components in distributed storage systems implement rigorous input sanitization protocols consistent with secure coding standards for memory management operations.