Re: [PATCH v2 5/6] selftests/landlock: Test capability checks outside the capable hook
From: Mickaël Salaün
Date: Wed Nov 18 2026 - 12:12:59 EST
v3 should address your review.
On Tue, Nov 17, 2026 at 05:11:54PM +0100, Günther Noack wrote:
> 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@xxxxxxxxxx>
> > Cc: Paul Moore <paul@xxxxxxxxxxxxxx>
> > Cc: Serge Hallyn <serge@xxxxxxxxxx>
> > Acked-by: Serge Hallyn (AMD) <sergeh@xxxxxxxxxx>
> > Signed-off-by: Mickaël Salaün <mic@xxxxxxxxxxx>
> > ---
> >
> > Changes since v1:
> > https://patch.msgid.link/20261110202436.2408244-6-mic@xxxxxxxxxxx
> > - 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@xxxxxxxxx/
>
> > + 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@xxxxxxxxx/
> 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
> >
>