Linux Security Modules development
 help / color / mirror / Atom feed
From: "Günther Noack" <gnoack@google.com>
To: "Mickaël Salaün" <mic@digikod.net>
Cc: Ada Smith <adasmithgt@gmail.com>,
	Hungyu Lin <dennylin0707@gmail.com>,
	James Morris <jmorris@namei.org>,
	Josef Bacik <josef@toxicpanda.com>,
	Paul Moore <paul@paul-moore.com>, Serge Hallyn <serge@hallyn.com>,
	Serge Hallyn <sergeh@kernel.org>,
	kernel-team@cloudflare.com, linux-kernel@vger.kernel.org,
	linux-security-module@vger.kernel.org
Subject: Re: [PATCH v2 5/6] selftests/landlock: Test capability checks outside the capable hook
Date: Tue, 17 Nov 2026 17:11:54 +0100	[thread overview]
Message-ID: <avx8yncGLuzDFVEa@google.com> (raw)
In-Reply-To: <20261117101157.2520463-6-mic@digikod.net>

On Tue, Nov 17, 2026 at 11:11:55AM +0100, Mickaël Salaün wrote:
> 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
> - 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?

> +{
> +	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)


> +	} 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/

> +		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.

> +
> +	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.


> +	}
> +	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/
which fixes this across all existing tests.


> +}
> +
> +/* 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.

> +}
> +
>  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
> 

  parent reply	other threads:[~2026-11-17 16:12 UTC|newest]

Thread overview: 18+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17 10:11 [PATCH v2 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
2026-11-17 10:11 ` [PATCH v2 1/6] landlock: Factor out capability denial checks Mickaël Salaün
2026-11-17 10:14   ` sashiko-bot
2026-11-17 13:56   ` Günther Noack
2026-11-17 10:11 ` [PATCH v2 2/6] landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr Mickaël Salaün
2026-11-17 10:18   ` sashiko-bot
2026-11-17 14:23   ` Günther Noack
2026-11-17 10:11 ` [PATCH v2 3/6] landlock: Mediate CAP_SETPCAP for inheritable capabilities Mickaël Salaün
2026-11-17 10:17   ` sashiko-bot
2026-11-17 15:41   ` Günther Noack
2026-11-17 10:11 ` [PATCH v2 4/6] landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve Mickaël Salaün
2026-11-17 10:16   ` sashiko-bot
2026-11-17 15:43   ` Günther Noack
2026-11-17 10:11 ` [PATCH v2 5/6] selftests/landlock: Test capability checks outside the capable hook Mickaël Salaün
2026-11-17 10:20   ` sashiko-bot
2026-11-17 16:11   ` Günther Noack [this message]
2026-11-17 10:11 ` [PATCH v2 6/6] landlock: Fix capability restriction documentation Mickaël Salaün
2026-11-17 10:17   ` sashiko-bot

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=avx8yncGLuzDFVEa@google.com \
    --to=gnoack@google.com \
    --cc=adasmithgt@gmail.com \
    --cc=dennylin0707@gmail.com \
    --cc=jmorris@namei.org \
    --cc=josef@toxicpanda.com \
    --cc=kernel-team@cloudflare.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-security-module@vger.kernel.org \
    --cc=mic@digikod.net \
    --cc=paul@paul-moore.com \
    --cc=serge@hallyn.com \
    --cc=sergeh@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox