Re: [PATCH v2 5/6] selftests/landlock: Test capability checks outside the capable hook

From
Günther Noack <gnoack@google.com>
Date
2026-11-17 16:12:02
Also in
lkml
Reply to
Mickaël Salaün, 2026-11-17
On Tue, Nov 17, 2026 at 11:11:55AM +0100, Mickaël Salaün wrote:
quoted hunk ↗ jump to hunk
Test the capability checks that commoncap makes from LSM hooks other
than capable and that the previous commits make Landlock restrict:
mapping below vm.mmap_min_addr (CAP_SYS_RAWIO) and adding inheritable
capabilities outside of the permitted set (CAP_SETPCAP).

Each test first checks that the operation fails without the capability,
so that it exercises the capability check, and then checks it with the
capability effective in four variants: unsandboxed, in a domain that
denies the capability, in a domain that allows it, and in a domain that
does not handle capabilities.  The mmap_addr tests map the last page
below vm.mmap_min_addr, and skip if the architecture rejects it before
the mmap_addr hook (e.g. 32-bit ARM).

Audit tests check that these denials are logged, that the admin reserve
check is not, and that allowed uses log nothing.  The admin reserve
check has no functional test: it only has an effect with
vm.overcommit_memory=2, a system-wide setting that a test cannot change
without racing with other processes.

Add CAP_SETPCAP and CAP_SYS_RAWIO to the capabilities that the tests may
raise, and drop the stale count from the comment of this list.

Without the mmap_addr and capset fixes, their denied variants and the
denial audit test fail.

Cc: Günther Noack <gnoack@google.com>
Cc: Paul Moore <paul@paul-moore.com>
Cc: Serge Hallyn <serge@hallyn.com>
Acked-by: Serge Hallyn (AMD) <sergeh@kernel.org>
Signed-off-by: Mickaël Salaün <mic@digikod.net>
---

Changes since v1:
https://patch.msgid.link/20261110202436.2408244-6-mic@digikod.net (local)
- Replace the admin reserve test, which changed system-wide overcommit
  settings and was racy (e.g. with swap, as reported by Sashiko), with a
  comment.
- Map the last page below vm.mmap_min_addr instead of page 0, and skip
  when the architecture rejects it, e.g. on 32-bit ARM (reported by
  Sashiko).
- Mention CAP_SETPCAP in the commit message (reported by Sashiko).
- Add Serge Hallyn's Acked-by.
---
 tools/testing/selftests/landlock/cap_test.c | 336 ++++++++++++++++++++
 tools/testing/selftests/landlock/common.h   |   4 +-
 2 files changed, 339 insertions(+), 1 deletion(-)
diff --git a/tools/testing/selftests/landlock/cap_test.c b/tools/testing/selftests/landlock/cap_test.c
index 3d7fd02e21ed..39ef57a49dc9 100644
--- a/tools/testing/selftests/landlock/cap_test.c
+++ b/tools/testing/selftests/landlock/cap_test.c
@@ -12,7 +12,9 @@
 #include <linux/landlock.h>
 #include <sched.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/wait.h>
 #include <sys/xattr.h>
@@ -738,6 +740,251 @@ TEST(cap_target_userns_independent)
 	EXPECT_EQ(0, close(target_userns_fd));
 }
 
+/*
+ * Capability checks that commoncap makes from hooks other than the capable
+ * hook.  Each test first checks that the operation needs the capability, then
+ * checks it with the capability effective.  Variants cover an unsandboxed
+ * baseline, a domain that denies the capability, a domain that allows it, and a
+ * domain that does not handle capabilities.
+ */
+/* clang-format off */
+FIXTURE(cap_other_hooks) {};
+/* clang-format on */
+
+FIXTURE_VARIANT(cap_other_hooks)
+{
+	const bool is_sandboxed;
+	const bool handle_caps;
+	const bool is_allowed;
+};
+
+/* clang-format off */
+FIXTURE_VARIANT_ADD(cap_other_hooks, unsandboxed) {
+	.is_sandboxed = false,
+	.handle_caps = false,
+	.is_allowed = true,
+};
+/* clang-format on */
+
+/* clang-format off */
+FIXTURE_VARIANT_ADD(cap_other_hooks, denied) {
+	.is_sandboxed = true,
+	.handle_caps = true,
+	.is_allowed = false,
+};
+/* clang-format on */
+
+/* clang-format off */
+FIXTURE_VARIANT_ADD(cap_other_hooks, allowed) {
+	.is_sandboxed = true,
+	.handle_caps = true,
+	.is_allowed = true,
+};
+/* clang-format on */
+
+/* clang-format off */
+FIXTURE_VARIANT_ADD(cap_other_hooks, unhandled) {
+	.is_sandboxed = true,
+	.handle_caps = false,
+	.is_allowed = true,
+};
+/* clang-format on */
+
+FIXTURE_SETUP(cap_other_hooks)
+{
+	disable_caps(_metadata);
+}
+
+FIXTURE_TEARDOWN(cap_other_hooks)
+{
+}
+
+/*
+ * Creates a ruleset that handles capabilities and allows @cap if @is_allowed,
+ * or, if !@handle_caps, a ruleset that only handles a filesystem access right.
+ * Returns the ruleset FD, or -1 with errno set.
+ */
+static int create_variant_ruleset(const bool handle_caps, const bool is_allowed,
+				  const int cap)
Nit: Maybe rename "is_allowed" to "allow_caps", so that it's a bit
clearer that this only makes sense in the case where caps are also
handled.  Or maybe just guard it on "cap" being non-zero, and rename
that appropriately?
quoted hunk ↗ jump to hunk
+{
+	const struct landlock_ruleset_attr fs_attr = {
+		.handled_access_fs = LANDLOCK_ACCESS_FS_READ_FILE,
+	};
+	int ruleset_fd, err;
+
+	if (!handle_caps)
+		return landlock_create_ruleset(&fs_attr, sizeof(fs_attr), 0);
+
+	ruleset_fd = create_cap_ruleset();
+	if (ruleset_fd < 0 || !is_allowed)
+		return ruleset_fd;
+
+	if (add_cap_rule(ruleset_fd, cap)) {
+		err = errno;
+		close(ruleset_fd);
+		errno = err;
+		return -1;
+	}
+	return ruleset_fd;
+}
+
+static void
+enforce_cap_variant(struct __test_metadata *const _metadata,
+		    const FIXTURE_VARIANT(cap_other_hooks) *const variant,
+		    const int cap)
+{
+	int ruleset_fd;
+
+	if (!variant->is_sandboxed)
+		return;
+
+	ruleset_fd = create_variant_ruleset(variant->handle_caps,
+					    variant->is_allowed, cap);
+	ASSERT_LE(0, ruleset_fd);
+	enforce_ruleset(_metadata, ruleset_fd);
+	EXPECT_EQ(0, close(ruleset_fd));
+}
+
+static unsigned long read_sysctl(struct __test_metadata *const _metadata,
+				 const char *const path)
+{
+	char buf[32];
+	ssize_t len;
+	int fd;
+
+	fd = open(path, O_RDONLY | O_CLOEXEC);
+	ASSERT_LE(0, fd)
+	{
+		TH_LOG("Failed to open %s: %s", path, strerror(errno));
+	}
+	len = read(fd, buf, sizeof(buf) - 1);
+	ASSERT_LT(0, len);
+	EXPECT_EQ(0, close(fd));
+
+	buf[len] = '\0';
+	return strtoul(buf, NULL, 10);
+}
+
+/*
+ * Returns the last page below the vm.mmap_min_addr sysctl, or MAP_FAILED if
+ * there is none or if the architecture rejects it before the mmap_addr hook
+ * (e.g. below FIRST_USER_ADDRESS on 32-bit ARM).  The caller must not have
+ * CAP_SYS_RAWIO in its effective set.
+ */
+static void *get_low_page(struct __test_metadata *const _metadata)
+{
+	const size_t page_size = sysconf(_SC_PAGESIZE);
+	unsigned long min_addr;
+	void *addr, *ret;
+
+	min_addr = read_sysctl(_metadata, "/proc/sys/vm/mmap_min_addr");
+	if (!min_addr)
+		return MAP_FAILED;
+
+	addr = (void *)((min_addr - 1) & ~(page_size - 1));
+	ret = mmap(addr, page_size, PROT_READ,
+		   MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+	ASSERT_EQ(MAP_FAILED, ret);
+	if (errno == EINVAL)
+		return MAP_FAILED;
+
+	ASSERT_EQ(EPERM, errno);
+	return addr;
+}
+
+/*
+ * cap_mmap_addr() requires CAP_SYS_RAWIO to map below the vm.mmap_min_addr
+ * sysctl (dac_mmap_min_addr).
+ */
+TEST_F(cap_other_hooks, mmap_min_addr)
+{
+	const size_t page_size = sysconf(_SC_PAGESIZE);
+	void *low_page, *addr;
+
+	low_page = get_low_page(_metadata);
+	if (low_page == MAP_FAILED)
+		SKIP(return, "Cannot map below vm.mmap_min_addr");
+
+	enforce_cap_variant(_metadata, variant, CAP_SYS_RAWIO);
+
+	addr = mmap(low_page, page_size, PROT_READ,
+		    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+	EXPECT_EQ(MAP_FAILED, addr);
+	EXPECT_EQ(EPERM, errno);
+
+	set_cap(_metadata, CAP_SYS_RAWIO);
+	addr = mmap(low_page, page_size, PROT_READ,
+		    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+	if (variant->is_allowed) {
+		EXPECT_EQ(low_page, addr)
+		{
+			TH_LOG("Failed to map below vm.mmap_min_addr: %s",
+			       strerror(errno));
+		}
+		if (addr != MAP_FAILED)
+			EXPECT_EQ(0, munmap(addr, page_size));
If you used ASSERT(low_page, addr) above, you would not need to check
for MAP_FAILED here.

I get the feeling that you are using EXPECT because you want to do the
munmap call?  Is that strictly necessary?  I believe that the tests
are running in a fork, so if they mess up their memory mapping, it
wouldn't be problematic?  (We already have many other cleanups that
don't get done properly if an ASSERT fails, e.g. FD closing)

quoted hunk ↗ jump to hunk
+	} else {
+		EXPECT_EQ(MAP_FAILED, addr);
+		EXPECT_EQ(EPERM, errno);
Same here.

errno is undefined unless the mmap failed, so the line checking for
MAP_FAILED should use ASSERT_EQ IMHO.

Compare my selftest cleanup commit for that at:
https://lore.kernel.org/all/20261104-selftests-refactor-v2-24-c52f23f7ce33@gmail.com/ (local)
quoted hunk ↗ jump to hunk
+		if (addr != MAP_FAILED)
+			munmap(addr, page_size);
+	}
+	clear_cap(_metadata, CAP_SYS_RAWIO);
+}
+
+static int add_inheritable_cap(const cap_value_t cap)
+{
+	cap_t cap_p;
+	int ret, err;
+
+	cap_p = cap_get_proc();
+	if (!cap_p)
+		return -1;
+
+	ret = cap_set_flag(cap_p, CAP_INHERITABLE, 1, &cap, CAP_SET);
+	if (!ret)
+		ret = cap_set_proc(cap_p);
+	err = errno;
+	cap_free(cap_p);
+	errno = err;
+	return ret;
+}
+
+/*
+ * cap_capset() requires CAP_SETPCAP to add an inheritable capability that is
+ * not in the permitted set.  CAP_NET_RAW is in the bounding set, but
+ * disable_caps() does not put it in the permitted set.
+ */
+TEST_F(cap_other_hooks, capset_inheritable)
+{
+	enforce_cap_variant(_metadata, variant, CAP_SETPCAP);
+
+	EXPECT_EQ(-1, add_inheritable_cap(CAP_NET_RAW));
+	EXPECT_EQ(EPERM, errno);
Ditto about errno checking and ASSERT.
quoted hunk ↗ jump to hunk
+
+	set_cap(_metadata, CAP_SETPCAP);
+	if (variant->is_allowed) {
+		EXPECT_EQ(0, add_inheritable_cap(CAP_NET_RAW))
+		{
+			TH_LOG("Failed to raise CAP_NET_RAW: %s",
+			       strerror(errno));
+		}
+	} else {
+		EXPECT_EQ(-1, add_inheritable_cap(CAP_NET_RAW));
+		EXPECT_EQ(EPERM, errno);
Also here (errno checking and ASSERT).  I'll refrain from commenting
on these further below to not spam you, but there are more instances
of it below.

quoted hunk ↗ jump to hunk
+	}
+	clear_cap(_metadata, CAP_SETPCAP);
+}
+
+/*
+ * cap_vm_enough_memory() lets CAP_SYS_ADMIN use the vm.admin_reserve_kbytes
+ * reserve, but only with vm.overcommit_memory=2.  The Landlock check of this
+ * reserve has no functional test: it would have to change these system-wide
+ * settings and set a tight commit limit, which could make allocations of other
+ * processes fail and would race with them.  cap_audit.other_hooks checks that
+ * this check is not logged.
+ */
+
 /* Audit tests */
 
 static int matches_log_cap(int audit_fd, int cap_number)
@@ -828,6 +1075,95 @@ TEST_F(cap_audit, denied)
 	EXPECT_EQ(0, records.domain);
 }
 
+/*
+ * Denials in the capset and mmap_addr paths are audited like capable hook
+ * denials.  The vm_enough_memory hook only withholds the admin reserve, with
+ * CAP_OPT_NOAUDIT, so an accounted mapping made with CAP_SYS_ADMIN effective
+ * leaves no record.
+ */
+TEST_F(cap_audit, other_hooks)
+{
+	const size_t page_size = sysconf(_SC_PAGESIZE);
+	struct audit_records records = {};
+	void *low_page, *addr;
+	int ruleset_fd;
+	__u64 domain_id;
+
+	low_page = get_low_page(_metadata);
+	ruleset_fd = create_cap_ruleset();
+	ASSERT_LE(0, ruleset_fd);
+	/* Allow CAP_AUDIT_CONTROL for child-side audit cleanup. */
+	ASSERT_EQ(0, add_cap_rule(ruleset_fd, CAP_AUDIT_CONTROL));
+	enforce_ruleset(_metadata, ruleset_fd);
+	EXPECT_EQ(0, close(ruleset_fd));
+
+	set_cap(_metadata, CAP_SETPCAP);
+	EXPECT_EQ(-1, add_inheritable_cap(CAP_NET_RAW));
+	EXPECT_EQ(EPERM, errno);
+	clear_cap(_metadata, CAP_SETPCAP);
+	EXPECT_EQ(0, matches_log_cap(self->audit_fd, CAP_SETPCAP));
+	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
+						  &domain_id));
+
+	if (low_page != MAP_FAILED) {
+		set_cap(_metadata, CAP_SYS_RAWIO);
+		addr = mmap(low_page, page_size, PROT_READ,
+			    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+		EXPECT_EQ(MAP_FAILED, addr);
+		EXPECT_EQ(EPERM, errno);
+		clear_cap(_metadata, CAP_SYS_RAWIO);
+		EXPECT_EQ(0, matches_log_cap(self->audit_fd, CAP_SYS_RAWIO));
+	}
+
+	set_cap(_metadata, CAP_SYS_ADMIN);
+	addr = mmap(NULL, page_size, PROT_READ | PROT_WRITE,
+		    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	EXPECT_NE(MAP_FAILED, addr);
+	clear_cap(_metadata, CAP_SYS_ADMIN);
+	if (addr != MAP_FAILED)
+		EXPECT_EQ(0, munmap(addr, page_size));
+
+	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	EXPECT_EQ(0, records.access);
+	EXPECT_EQ(0, records.domain);
Similar problem: "records" is undefined if audit_count_records fails,
so audit_count_records should use ASSERT.  See
https://lore.kernel.org/all/20261104-selftests-refactor-v2-12-c52f23f7ce33@gmail.com/ (local)
which fixes this across all existing tests.

quoted hunk ↗ jump to hunk
+}
+
+/* Allowed capability uses in the capset and mmap_addr paths. */
+TEST_F(cap_audit, other_hooks_allowed)
+{
+	const size_t page_size = sysconf(_SC_PAGESIZE);
+	struct audit_records records = {};
+	void *low_page, *addr;
+	int ruleset_fd;
+
+	low_page = get_low_page(_metadata);
+	ruleset_fd = create_cap_ruleset();
+	ASSERT_LE(0, ruleset_fd);
+	ASSERT_EQ(0, add_cap_rule(ruleset_fd, CAP_SETPCAP));
+	ASSERT_EQ(0, add_cap_rule(ruleset_fd, CAP_SYS_RAWIO));
+	/* Allow CAP_AUDIT_CONTROL for child-side audit cleanup. */
+	ASSERT_EQ(0, add_cap_rule(ruleset_fd, CAP_AUDIT_CONTROL));
+	enforce_ruleset(_metadata, ruleset_fd);
+	EXPECT_EQ(0, close(ruleset_fd));
+
+	set_cap(_metadata, CAP_SETPCAP);
+	EXPECT_EQ(0, add_inheritable_cap(CAP_NET_RAW));
+	clear_cap(_metadata, CAP_SETPCAP);
+
+	if (low_page != MAP_FAILED) {
+		set_cap(_metadata, CAP_SYS_RAWIO);
+		addr = mmap(low_page, page_size, PROT_READ,
+			    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+		EXPECT_EQ(low_page, addr);
+		clear_cap(_metadata, CAP_SYS_RAWIO);
+		if (addr != MAP_FAILED)
+			EXPECT_EQ(0, munmap(addr, page_size));
+	}
+
+	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	EXPECT_EQ(0, records.access);
Here as well.
quoted hunk ↗ jump to hunk
+}
+
 TEST_F(cap_audit, allowed)
 {
 	struct audit_records records = {};
diff --git a/tools/testing/selftests/landlock/common.h b/tools/testing/selftests/landlock/common.h
index e29406900c04..a6fdfb422fad 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -36,7 +36,7 @@ static const char bin_wait_pipe_sandbox[] = "./wait-pipe-sandbox";
 static void _init_caps(struct __test_metadata *const _metadata, bool drop_all)
 {
 	cap_t cap_p;
-	/* Only these three capabilities are useful for the tests. */
+	/* Only these capabilities are useful for the tests. */
 	const cap_value_t caps[] = {
 		/* clang-format off */
 		CAP_AUDIT_CONTROL,
@@ -44,9 +44,11 @@ static void _init_caps(struct __test_metadata *const _metadata, bool drop_all)
 		CAP_MKNOD,
 		CAP_NET_ADMIN,
 		CAP_NET_BIND_SERVICE,
+		CAP_SETPCAP,
 		CAP_SETUID,
 		CAP_SYS_ADMIN,
 		CAP_SYS_CHROOT,
+		CAP_SYS_RAWIO,
 		/* clang-format on */
 	};
 	const unsigned int noroot = SECBIT_NOROOT | SECBIT_NOROOT_LOCKED;
-- 
2.56.0
Thread (23 messages) 23 messages, 3 authors, last reply 3h ago
Keyboard shortcuts
hback out one level
jnext message in thread / next series-diff position
kprevious message in thread / previous series-diff position
ldrill in
Escclose help / fold thread tree
?toggle this help