Description

In the Linux kernel, the following vulnerability has been resolved: ceph: bound num_export_targets array for mds info v2/v3 ceph_mdsmap_decode() in fs/ceph/mdsmap.c reads num_export_targets from each per-mds info record and advances the decode cursor by num_export_targets * sizeof(u32) without first checking that many bytes remain. The only upper-bound check that catches a runaway cursor (*p > info_end) is gated on info_v >= 4, because info_end is left NULL for info_v 2 and 3. When the monitor sends an MDS map whose per-mds info version is 2 or 3 with an oversized num_export_targets, the cursor moves past the message front buffer and the later export-targets loop calls the unchecked ceph_decode_32() on out-of-bounds memory. A kernel client processes CEPH_MSG_MDS_MAP from its monitor session (net/ceph/mon_client.c dispatches it; fs/ceph/super.c routes it to ceph_mdsc_handle_mdsmap(), which sets end to the front buffer bound and calls ceph_mdsmap_decode()). A malicious or compromised monitor, or an on-path attacker on an unsigned/unencrypted messenger session, can therefore drive an out-of-bounds read in the client kernel; on x86_64 with KASAN it is reported as a slab-out-of-bounds read in ceph_mdsmap_decode(). The decoded values land in the internal info->export_targets[] array, so the consequence is a kernel out-of-bounds read, not an information leak to the attacker. Impact: a malicious or compromised Ceph monitor sending an MDS map with a per-mds info version of 2 or 3 and an oversized num_export_targets field triggers an out-of-bounds read in the CephFS client kernel. Add a ceph_decode_need() for the export-targets array before advancing the cursor, so the bound is enforced for every info_v >= 2, not only info_v >= 4. This mirrors the count-then-need idiom already used for m_data_pg_pools later in the same function. Compute the export-targets byte count with size_mul() and reuse that checked length when advancing the cursor, so the attacker-controlled num_export_targets multiplication fails closed on overflow rather than relying on the later kcalloc() guard.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "9.1",
  "pubDate": "2026-09-11T20:19:51.023Z",
  "pubdate": "2026-09-11T20:19:51.023Z",
  "executiveSummary": "The Linux kernel CephFS client is vulnerable to an out-of-bounds (OOB) read due to insufficient validation of metadata fields during MDS map decoding.\nThis vulnerability, rooted in the ceph_mdsmap_decode() function, occurs when processing MDS map versions 2 or 3, where the 'num_export_targets' field is not correctly bounded against the message buffer size.\nA malicious or compromised monitor, or an on-path attacker intercepting unencrypted traffic, can supply a specially crafted MDS map containing an oversized 'num_export_targets' value.\nSuccessful exploitation forces the kernel to read memory beyond the allocated buffer bounds, potentially leading to a kernel panic or denial-of-service (DoS) condition.\nWhile the primary impact is identified as a kernel OOB read rather than an information leak, this behavior exposes the system to crashes when parsing untrusted or malicious Ceph monitor communications.",
  "technicalDetails": "The vulnerability resides within the fs/ceph/mdsmap.c file in the Linux kernel, specifically within the ceph_mdsmap_decode() function responsible for parsing MDS map structures sent by the monitor.\nThe root cause is an improper bounds check for the 'num_export_targets' array when the MDS info version is set to 2 or 3. In the vulnerable implementation, the code increments the decode cursor based on 'num_export_targets * sizeof(u32)' without verifying that these bytes exist within the remaining message buffer.\nUnlike info versions >= 4, which use an 'info_end' boundary check, versions 2 and 3 fail to enforce this constraint. This allows the decoder to advance the pointer past the allocated memory front buffer.\nThe attack flow initiates when the client kernel receives a CEPH_MSG_MDS_MAP from the monitor. If an attacker controls the monitor or acts as a man-in-the-middle on an unencrypted/unsigned messenger session, they can craft an MDS map with an inflated 'num_export_targets' field.\nWhen the client processes this malformed map, the decoder moves the cursor out-of-bounds. Subsequently, the function invokes ceph_decode_32() on out-of-bounds memory. On x86_64 architectures, this triggers a KASAN-reported slab-out-of-bounds read.\nThe technical failure is exacerbated by the lack of integer overflow protection during the calculation of the array size. Using size_mul() for the export-targets byte count is necessary to ensure that overflows in the 'num_export_targets' multiplication cause the decoding process to fail closed.\nBy adding ceph_decode_need() calls, the kernel can enforce buffer boundary integrity for all info_v >= 2 versions, aligning the parsing logic with the safer count-then-need pattern used later in the function for 'm_data_pg_pools'.\nThe exploitation does not facilitate remote code execution directly, but the OOB read can cause immediate kernel instability, resulting in a system-wide denial-of-service. Attackers require the ability to influence or spoof monitor-to-client communication."
}