Skip to contentSkip to conversation

libceph: validate OSD sparse-read extent maps (+KUnit)

PATCH In review Michael Bommarito 3 participants 5 messages Jul 14 – Aug 11

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

v2 cover libceph: validate OSD sparse-read extent maps (+KUnit)

Patch 1 is the fix from v1 (unchanged), now carrying Viacheslav Dubeyko's Reviewed-by. Patch 2 adds the KUnit coverage he asked for.

osd_sparse_read() checks that the sparse-read data length matches the summed extent lengths but never checks that each OSD-supplied extent is monotonic and stays inside the original request range, so a malformed authenticated OSD reply can advance the message-data cursor past the request buffer and hit the BUG_ON(!*length) in ceph_msg_data_next(). Patch 1 rejects such maps before advancing the cursor.

The KUnit suite in patch 2 drives the real osd_sparse_read() state machine over a synthesized reply (no OSD, no network). Confirmed before/after on v7.2-rc3: without patch 1 the out-of-range case faults in ceph_msg_data_next() while the in-range control passes (1 pass, 1 fail); with patch 1 both pass.

v1: https://lore.kernel.org/ceph-devel/20260710022837.libceph-sparse-v1@bommarito/

Michael Bommarito (2):
libceph: validate OSD extent maps before cursor advance
libceph: add KUnit coverage for OSD sparse-read extent validation

 net/ceph/Kconfig            |  12 +++
 net/ceph/osd_client-kunit.c | 146 ++++++++++++++++++++++++++++++++++++
 net/ceph/osd_client.c       |  34 +++++++++
 3 files changed, 192 insertions(+)
 create mode 100644 net/ceph/osd_client-kunit.c
Signature · 1 line
2.53.0
#1 lore raw

PATCH v2 1/2 libceph: validate OSD extent maps before cursor advance

net/ceph/osd_client.c:osd_sparse_read() validates that the sparse-read data length matches the summed extent lengths, but it does not validate that each OSD-supplied extent is monotonic and lies inside the original request range. A malformed authenticated OSD reply can advertise a far-forward nonzero extent offset with a matching data length and make the client advance the message-data cursor beyond the request buffer. This reaches the BUG_ON(!*length) assertion in ceph_msg_data_next() from the client receive path.

Impact: A malicious or compromised authenticated Ceph OSD peer can crash a kernel Ceph client via a malformed sparse-read reply.

Reject sparse extent maps that overflow, move backwards, overlap, or extend outside the original sparse-read request before advancing the cursor.

Fixes f628d7999727 ("libceph: add sparse read support to OSD client")
Assisted-by Codex:gpt-5-5-xhigh
---
 net/ceph/osd_client.c | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
net/ceph/osd_client.c +30 -0
index 2ff00070c1810..76ba3abdad9b1 100644
@@ -6,6 +6,7 @@
 #include <linux/err.h>
 #include <linux/highmem.h>
 #include <linux/mm.h>
+#include <linux/overflow.h>
 #include <linux/pagemap.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
@@ -5799,6 +5800,31 @@ static inline void convert_extent_map(struct ceph_sparse_read *sr)
 }
 #endif
 
+static bool sparse_extent_map_valid(struct ceph_sparse_read *sr)
+{
+	u64 req_end, pos;
+	int i;
+
+	if (check_add_overflow(sr->sr_req_off, sr->sr_req_len, &req_end))
+		return false;
+
+	pos = sr->sr_req_off;
+	for (i = 0; i < sr->sr_count; i++) {
+		struct ceph_sparse_extent *ext = &sr->sr_extent[i];
+		u64 end;
+
+		if (ext->off < pos)
+			return false;
+		if (check_add_overflow(ext->off, ext->len, &end))
+			return false;
+		if (end > req_end)
+			return false;
+		pos = end;
+	}
+
+	return true;
+}
+
 static int osd_sparse_read(struct ceph_connection *con,
 			   struct ceph_msg_data_cursor *cursor,
 			   char **pbuf)
@@ -5856,6 +5882,10 @@ static int osd_sparse_read(struct ceph_connection *con,
 	case CEPH_SPARSE_READ_DATA_PRE:
 		/* Convert sr_datalen to host-endian */
 		sr->sr_datalen = le32_to_cpu((__force __le32)sr->sr_datalen);
+		if (!sparse_extent_map_valid(sr)) {
+			pr_warn_ratelimited("invalid sparse extent map\n");
+			return -EREMOTEIO;
+		}
 		for (i = 0; i < count; i++)
 			len += sr->sr_extent[i].len;
 		if (sr->sr_datalen != len) {
Signature · 1 line
2.53.0
#2 lore raw

PATCH v2 2/2 libceph: add KUnit coverage for OSD sparse-read extent validation

In reply to Michael Bommarito

Add KUnit coverage for the sparse-read extent-map validation added by the previous patch. The tests drive the real osd_sparse_read() state machine over a synthesized OSD reply (no OSD or network): an in-range single extent is accepted and advances the cursor, and an extent whose offset lies outside the original request range is rejected with -EREMOTEIO before the message-data cursor is advanced.

The suite is included from osd_client.c so it can exercise the static sparse-read parser and cursor-advance helpers without exporting test-only symbols, guarded by CONFIG_CEPH_LIB_KUNIT_TEST.

Assisted-by Codex:gpt-5-5-xhigh
---
 net/ceph/Kconfig            |  12 +++
 net/ceph/osd_client-kunit.c | 146 ++++++++++++++++++++++++++++++++++++
 net/ceph/osd_client.c       |   4 +
 3 files changed, 162 insertions(+)
 create mode 100644 net/ceph/osd_client-kunit.c
net/ceph/Kconfig +12 -0
index 7e2528cde4b94..6b78fe4a0f8a4 100644
@@ -45,3 +45,15 @@ config CEPH_LIB_USE_DNS_RESOLVER
 	  Documentation/networking/dns_resolver.rst
 
 	  If unsure, say N.
+
+config CEPH_LIB_KUNIT_TEST
+	bool "KUnit tests for the Ceph core library" if !KUNIT_ALL_TESTS
+	depends on CEPH_LIB && KUNIT
+	default KUNIT_ALL_TESTS
+	help
+	  This builds KUnit coverage for selected Ceph core-library parser
+	  and state-machine helpers. The tests exercise internal libceph
+	  behavior with synthesized state and are intended for developer
+	  validation rather than production systems.
+
+	  If unsure, say N.
net/ceph/osd_client-kunit.c new file +146 -0

146 lines not on this page · raw message

net/ceph/osd_client.c +4 -0
index 76ba3abdad9b1..b9ab9608ec88e 100644
@@ -5951,3 +5951,7 @@ static const struct ceph_connection_operations osd_con_ops = {
 	.handle_auth_done = osd_handle_auth_done,
 	.handle_auth_bad_method = osd_handle_auth_bad_method,
 };
+
+#ifdef CONFIG_CEPH_LIB_KUNIT_TEST
+#include "osd_client-kunit.c"
+#endif
Signature · 1 line
2.53.0
#3 lore raw

Re: [PATCH v2 2/2] libceph: add KUnit coverage for OSD sparse-read extent validation

Quoted 224 lines · Michael Bommarito

Add KUnit coverage for the sparse-read extent-map validation added by the
previous patch. The tests drive the real osd_sparse_read() state machine
over a synthesized OSD reply (no OSD or network): an in-range single extent is accepted and advances the cursor, and an extent whose offset
lies outside the original request range is rejected with -EREMOTEIO before
the message-data cursor is advanced.

The suite is included from osd_client.c so it can exercise the static sparse-read parser and cursor-advance helpers without exporting test- only
symbols, guarded by CONFIG_CEPH_LIB_KUNIT_TEST.

Assisted-by Codex:gpt-5-5-xhigh

---
 net/ceph/Kconfig            |  12 +++
 net/ceph/osd_client-kunit.c | 146
++++++++++++++++++++++++++++++++++++
 net/ceph/osd_client.c       |   4 +

 3 files changed, 162 insertions(+)

 create mode 100644 net/ceph/osd_client-kunit.c

net/ceph/Kconfig +0 -0
index 7e2528cde4b94..6b78fe4a0f8a4 100644
@@ -45,3 +45,15 @@ config CEPH_LIB_USE_DNS_RESOLVER

    Documentation/networking/dns_resolver.rst
    If unsure, say N.

net/ceph/Kconfig +3 -0
+
+config CEPH_LIB_KUNIT_TEST
+	bool "KUnit tests for the Ceph core library" if

!KUNIT_ALL_TESTS

net/ceph/Kconfig +4 -0
+	depends on CEPH_LIB && KUNIT
+	default KUNIT_ALL_TESTS
+	help
+	  This builds KUnit coverage for selected Ceph core-library

parser

net/ceph/Kconfig +1 -0
+	  and state-machine helpers. The tests exercise internal

libceph

net/ceph/Kconfig +1 -0
+	  behavior with synthesized state and are intended for

developer

net/ceph/Kconfig +3 -0
+	  validation rather than production systems.
+
+	  If unsure, say N.
net/ceph/osd_client- renamed from net/ceph/osd_client-kunit.c +0 -0

kunit.c
new file mode 100644
index 0000000000000..713f24675f68f

net/ceph/osd_client-kunit.c new file +5 -0
@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit coverage for net/ceph/osd_client.c internals.
+ *
+ * Included from osd_client.c so the test can drive the real static

sparse-read
+ * parser and cursor-advance helper without exporting test-only symbols.
+ */

net/ceph/osd_client-kunit.c new file +21 -0
+
+#include <kunit/test.h>
+
+struct ceph_osd_sparse_read_test {
+	struct ceph_osd osd;
+	struct ceph_connection con;
+	struct ceph_msg *msg;
+	struct ceph_msg_data_cursor cursor;
+	struct ceph_osd_request *req;
+	struct page **pages;
+	struct page *page;
+};
+
+static int ceph_osd_sparse_read_test_init(struct kunit *test)
+{
+	struct ceph_osd_sparse_read_test *ctx;
+
+	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, ctx);
+
+	ctx->req = kunit_kzalloc(test, struct_size(ctx->req, r_ops,

1),

net/ceph/osd_client-kunit.c new file +4 -0
+				 GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, ctx->req);
+
+	ctx->pages = kunit_kcalloc(test, 1, sizeof(*ctx->pages),

GFP_KERNEL);

net/ceph/osd_client-kunit.c new file +7 -0
+	KUNIT_ASSERT_NOT_NULL(test, ctx->pages);
+
+	ctx->page = alloc_page(GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, ctx->page);
+	ctx->pages[0] = ctx->page;
+
+	ctx->msg = ceph_msg_new2(CEPH_MSG_OSD_OPREPLY, 0, 1,

GFP_KERNEL, true);

net/ceph/osd_client-kunit.c new file +12 -0
+	KUNIT_ASSERT_NOT_NULL(test, ctx->msg);
+
+	osd_init(&ctx->osd);
+	ctx->osd.o_sparse_op_idx = -1;
+	ceph_init_sparse_read(&ctx->osd.o_sparse_read);
+
+	request_init(ctx->req);
+	ctx->req->r_tid = 1;
+	ctx->req->r_num_ops = 1;
+	osd_req_op_extent_init(ctx->req, 0, CEPH_OSD_OP_SPARSE_READ,
+			       0, PAGE_SIZE, 0, 0);
+	KUNIT_ASSERT_EQ(test, ctx->req->r_ops[0].op,

CEPH_OSD_OP_SPARSE_READ);

net/ceph/osd_client-kunit.c new file +5 -0
+
+	insert_request(&ctx->osd.o_requests, ctx->req);
+
+	ctx->msg->hdr.tid = cpu_to_le64(ctx->req->r_tid);
+	ceph_msg_data_add_pages(ctx->msg, ctx->pages, PAGE_SIZE, 0,

false);

net/ceph/osd_client-kunit.c new file +1 -0
+	ceph_msg_data_cursor_init(&ctx->cursor, ctx->msg,

PAGE_SIZE);

net/ceph/osd_client-kunit.c new file +26 -0
+
+	ctx->con.private = &ctx->osd;
+	ctx->con.in_msg = ctx->msg;
+
+	test->priv = ctx;
+	return 0;
+}
+
+static void ceph_osd_sparse_read_test_exit(struct kunit *test)
+{
+	struct ceph_osd_sparse_read_test *ctx = test->priv;
+
+	if (!ctx)
+		return;
+
+	if (ctx->req && !RB_EMPTY_NODE(&ctx->req->r_node))
+		erase_request(&ctx->osd.o_requests, ctx->req);
+	ceph_init_sparse_read(&ctx->osd.o_sparse_read);
+	if (ctx->msg)
+		ceph_msg_put(ctx->msg);
+	if (ctx->page)
+		__free_page(ctx->page);
+}
+
+static int ceph_osd_sparse_read_feed_one_extent(struct kunit *test,
+						u64 off, u64 len,

u32 datalen)

net/ceph/osd_client-kunit.c new file +41 -0
+{
+	struct ceph_osd_sparse_read_test *ctx = test->priv;
+	struct ceph_sparse_read *sr = &ctx->osd.o_sparse_read;
+	char *buf = NULL;
+	int ret;
+
+	ret = osd_sparse_read(&ctx->con, &ctx->cursor, &buf);
+	KUNIT_ASSERT_EQ(test, ret, (int)sizeof(sr->sr_count));
+	KUNIT_ASSERT_PTR_EQ(test, buf, (char *)&sr->sr_count);
+
+	sr->sr_count = (__force u32)cpu_to_le32(1);
+	ret = osd_sparse_read(&ctx->con, &ctx->cursor, &buf);
+	KUNIT_ASSERT_EQ(test, ret, (int)sizeof(*sr->sr_extent));
+	KUNIT_ASSERT_NOT_NULL(test, sr->sr_extent);
+	KUNIT_ASSERT_PTR_EQ(test, buf, (char *)sr->sr_extent);
+
+	sr->sr_extent[0].off = (__force u64)cpu_to_le64(off);
+	sr->sr_extent[0].len = (__force u64)cpu_to_le64(len);
+	ret = osd_sparse_read(&ctx->con, &ctx->cursor, &buf);
+	KUNIT_ASSERT_EQ(test, ret, (int)sizeof(sr->sr_datalen));
+	KUNIT_ASSERT_PTR_EQ(test, buf, (char *)&sr->sr_datalen);
+
+	sr->sr_datalen = (__force u32)cpu_to_le32(datalen);
+	return osd_sparse_read(&ctx->con, &ctx->cursor, &buf);
+}
+
+static void ceph_osd_sparse_read_in_range_extent(struct kunit *test)
+{
+	struct ceph_osd_sparse_read_test *ctx = test->priv;
+	struct ceph_sparse_read *sr = &ctx->osd.o_sparse_read;
+	int ret;
+
+	ret = ceph_osd_sparse_read_feed_one_extent(test, 0, 16, 16);
+
+	KUNIT_EXPECT_EQ(test, ret, 16);
+	KUNIT_EXPECT_EQ(test, sr->sr_pos, 16);
+	KUNIT_EXPECT_EQ(test, ctx->cursor.sr_resid, 16);
+	KUNIT_EXPECT_EQ(test, ctx->cursor.resid, PAGE_SIZE);
+}
+
+static void ceph_osd_sparse_read_rejects_out_of_range_extent(struct

kunit *test)

net/ceph/osd_client-kunit.c new file +4 -0
+{
+	int ret;
+
+	ret = ceph_osd_sparse_read_feed_one_extent(test, PAGE_SIZE +

16, 16, 16);

net/ceph/osd_client-kunit.c new file +7 -0
+
+	KUNIT_EXPECT_EQ(test, ret, -EREMOTEIO);
+}
+
+static struct kunit_case ceph_osd_sparse_read_test_cases[] = {
+	KUNIT_CASE(ceph_osd_sparse_read_in_range_extent),
+	KUNIT_CASE(ceph_osd_sparse_read_rejects_out_of_range_extent)

,

net/ceph/osd_client-kunit.c new file +11 -0
+	{}
+};
+
+static struct kunit_suite ceph_osd_sparse_read_test_suite = {
+	.name = "ceph_osd_sparse_read",
+	.init = ceph_osd_sparse_read_test_init,
+	.exit = ceph_osd_sparse_read_test_exit,
+	.test_cases = ceph_osd_sparse_read_test_cases,
+};
+
+kunit_test_suite(ceph_osd_sparse_read_test_suite);
net/ceph/osd_client.c +0 -0
index 76ba3abdad9b1..b9ab9608ec88e 100644
@@ -5951,3 +5951,7 @@ static const struct ceph_connection_operations
 osd_con_ops = {
  	.handle_auth_done = osd_handle_auth_done,
  	.handle_auth_bad_method = osd_handle_auth_bad_method,

 };

net/ceph/osd_client.c static const struct ceph_connection_operations osd_con_ops = { · line 5957

Quoted 4 lines
net/ceph/osd_client.c +4 -0
+
+#ifdef CONFIG_CEPH_LIB_KUNIT_TEST
+#include "osd_client-kunit.c"
+#endif

Usually, KUnit test requires .kunitconfig file and I don't see it. Because, there are several ways to run Kunit tests: (1) python script,
(2) running kernel module.

The osd_client-kunit.c should contains:
MODULE_LICENSE()
MODULE_AUTHOR()
MODULE_DESCRIPTION()
MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");

The tested function needs to be properly exported:

EXPORT_SYMBOL_IF_KUNIT(<function_name>);

Thanks,
Slava.

maintainer
#4 lore raw

Re: [PATCH v2 2/2] libceph: add KUnit coverage for OSD sparse-read extent validation

In reply to Michael Bommarito

Hi Michael,

A few issues with the test code:

The test suite leaks the page allocated in osd_sparse_read_test_init() when an early assertion fails before cleanup runs. The insert_request() and erase_request() calls in the test body also lack the locking that the production code requires around them.

Also, Slava raised a concern about the KUnit integration approach that hasn't been addressed — please make sure that's resolved before v3.

Could you respin?

--
Alex Markuze