* [BUG] Landlock denies LANDLOCK_ACCESS_FS_EXECUTE despite a correctly-anchored PathBeneath rule (contradicts selftest layout1.execute)
@ 2026-07-14 21:07 Ken Grimes
2026-07-15 8:39 ` Günther Noack
0 siblings, 1 reply; 2+ messages in thread
From: Ken Grimes @ 2026-07-14 21:07 UTC (permalink / raw)
To: linux-security-module@vger.kernel.org
Cc: Mickaël Salaün, Günther Noack
[-- Attachment #1.1.1: Type: text/plain, Size: 16855 bytes --]
Hey all, this is my first bug report for linux. The issue was discovered
alongside llm-assisted coding on a downstream project. The
investigation/testing of the bug was a mostly manual process so I could
be sure this was something real. Please let me know if I can provide any
further details or assistance. Hope this is helpful, thank you for all of your
hard work!
Summary
-------
On Linux 7.1.3 (Fedora 44, Landlock ABI version 9), a minimal, correctly
constructed Landlock ruleset denies execve()/execveat() of that file with
EACCES. This directly contradicts the expected behavior of the official
selftest assertion: tools/testing/selftests/landlock/fs_test.c's
TEST_F_FORK(layout1, execute), specifically the file1_s1d2 case,
expects exactly this shape of rule to permit execution
(test_execute(_metadata, 0, file1_s1d2)).
This was confirmed two ways: a minimal standalone reproduction (below),
and by building and running your own unmodified
tools/testing/selftests/landlock/fs_test.c from the v7.1.3 tag (exact
match to the running kernel and its kernel-headers package) against this
kernel. layout1.execute fails on this kernel:
# RUN layout1.execute ...
# fs_test.c:1949:execute:Expected err ? -1 : 0 (0) == execve(path, argv, NULL) (-1)
# fs_test.c:1951:execute:Failed to execute "tmp/s1d1/s1d2/f1": Permission denied
# execute: Test terminated by assertion
# FAIL layout1.execute
not ok 29 layout1.execute
tmp/s1d1/s1d2/f1 is file1_s1d2 is the file living directly inside
dir_s1d2, which is the directory the test's own PathBeneath rule
anchors on (rules[0] = { .path = dir_s1d2, .access =
LANDLOCK_ACCESS_FS_EXECUTE }). The failing assertion is
test_execute(_metadata, 0, file1_s1d2) (fs_test.c:1949 in the v7.1.3
tree, quoted below). The test's author expects this call to succeed
(err == 0), and on this kernel it doesn't. Full raw test output is
attached (official-selftest-output.log).
Relevant excerpt of the actual test body (identical across the v7.1.3
tag and current master):
TEST_F_FORK(layout1, execute)
{
const struct rule rules[] = {
{
.path = dir_s1d2,
.access = LANDLOCK_ACCESS_FS_EXECUTE,
},
{},
};
copy_file(_metadata, bin_true, file1_s1d1);
copy_file(_metadata, bin_true, file1_s1d2);
copy_file(_metadata, bin_true, file1_s1d3);
/* Checks before file1_s1d1 being denied. */
test_execute(_metadata, 0, file1_s1d1);
test_check_exec(_metadata, 0, file1_s1d1);
enforce_fs(_metadata, rules[0].access, rules);
ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY));
ASSERT_EQ(0, test_open(file1_s1d1, O_RDONLY));
test_execute(_metadata, EACCES, file1_s1d1);
test_check_exec(_metadata, EACCES, file1_s1d1);
ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY));
ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
test_execute(_metadata, 0, file1_s1d2); /* <-- fails here */
test_check_exec(_metadata, 0, file1_s1d2);
...
(Reproducing the official fixture required running from a
world-writable directory: prepare_layout_opt() calls disable_caps()
which drops CAP_DAC_OVERRIDE from the otherwise-root test process,
before creating its working directory, so it must be run from
somewhere an unprivileged-DAC root can still write, e.g. under /tmp
directly. This is unrelated to the actual bug, just a note for anyone
else reproducing it.)
Environment
-----------
- Kernel: 7.1.3-200.fc44.x86_64 (Fedora 44 Workstation)
- Landlock ABI version: 9 (via landlock_create_ruleset(NULL, 0,
LANDLOCK_CREATE_RULESET_VERSION))
- kernel-headers package: kernel-headers-7.1.3-200.fc44.x86_64
(exact version match to the running kernel; the reproduction below was
built against these headers)
- No root/CAP_SYS_ADMIN involved anywhere in the reproduction -- Landlock
is unprivileged by design, and this reproduces identically as an
ordinary user.
Reproduction
------------
Official selftest (strongest evidence):
$ git clone --branch v7.1.3 --depth 1 https://github.com/gregkh/linux
$ cd linux/tools/testing/selftests/landlock
$ gcc -O0 -g -Wall -o fs_test fs_test.c -lcap -lpthread
$ gcc -O0 -o true true.c
$ mkdir -p /tmp/lltest && chmod 1777 /tmp/lltest
$ cp fs_test true /tmp/lltest/ && cd /tmp/lltest
$ sudo ./fs_test -f layout1 -t execute
(Run from a world-writable directory. See the note above about
disable_caps()) Full output attached as official-selftest-output.log.
Minimal standalone reproduction (self-contained, no external
dependencies beyond libc and the system's own <linux/landlock.h>,
unprivileged, attached as repro.c):
/*
* Minimal standalone reproduction of a Landlock EXECUTE-right denial that
* contradicts the upstream kernel's own selftest expectation.
*
* This mirrors tools/testing/selftests/landlock/fs_test.c's
* TEST_F_FORK(layout1, execute) -- specifically the file1_s1d2 case: a
* PathBeneath rule granting only LANDLOCK_ACCESS_FS_EXECUTE, anchored on a
* directory, is expected to permit execve() of a file directly inside that
* directory (upstream asserts test_execute(_metadata, 0, file1_s1d2), i.e.
* "no error"). On this kernel it is denied with EACCES instead.
*
* No root/CAP_SYS_ADMIN required -- Landlock is designed for unprivileged
* use, and this reproduces the same way as an ordinary user.
*
* Build: gcc -O0 -g -Wall -o repro repro.c
* Run: ./repro
*
* Observed on: Linux 7.1.3-200.fc44.x86_64 (Fedora 44 Workstation),
* Landlock ABI version 9 (per landlock_create_ruleset(NULL, 0,
* LANDLOCK_CREATE_RULESET_VERSION)).
*/
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <linux/landlock.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
static int landlock_create_ruleset(const struct landlock_ruleset_attr *attr,
size_t size, __u32 flags)
{
return syscall(SYS_landlock_create_ruleset, attr, size, flags);
}
static int landlock_add_rule(int ruleset_fd, enum landlock_rule_type type,
const void *attr, __u32 flags)
{
return syscall(SYS_landlock_add_rule, ruleset_fd, type, attr, flags);
}
static int landlock_restrict_self(int ruleset_fd, __u32 flags)
{
return syscall(SYS_landlock_restrict_self, ruleset_fd, flags);
}
static void die(const char *what)
{
fprintf(stderr, "%s: %s\n", what, strerror(errno));
exit(1);
}
/* Runs `path` via a fresh execve() in a child, prints and returns its result. */
static int try_execve(const char *path)
{
pid_t pid = fork();
if (pid < 0)
die("fork");
if (pid == 0) {
char *const argv[] = { (char *)path, NULL };
execve(path, argv, NULL);
/* Only reached on failure. */
fprintf(stderr, "execve(%s) failed: %s (errno %d)\n", path,
strerror(errno), errno);
_exit(1);
}
int status;
waitpid(pid, &status, 0);
if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
return 0;
return 1;
}
int main(void)
{
int abi = landlock_create_ruleset(NULL, 0,
LANDLOCK_CREATE_RULESET_VERSION);
printf("Landlock ABI version: %d\n", abi);
if (abi < 0)
die("landlock_create_ruleset(VERSION)");
/* Build tmp/dir/exe, matching layout1's dir_s1d2/file1_s1d2 shape:
* a rule anchored on the parent directory, target file directly
* inside it (zero levels of extra nesting). */
if (mkdir("repro-dir", 0700) < 0 && errno != EEXIST)
die("mkdir repro-dir");
/* Copy /bin/true in as our target executable. */
{
char cmd[256];
snprintf(cmd, sizeof(cmd),
"cp /bin/true repro-dir/exe && chmod 755 repro-dir/exe");
if (system(cmd) != 0)
die("cp /bin/true");
}
/* Baseline: confirm it executes fine before Landlock is involved. */
if (try_execve("repro-dir/exe") != 0) {
fprintf(stderr, "baseline execve failed even without Landlock -- "
"environment problem, not a Landlock issue\n");
return 1;
}
printf("Baseline (no Landlock): execve succeeded, as expected.\n");
/* Minimal ruleset: EXECUTE only, matching the official selftest's
* rules[0].access = LANDLOCK_ACCESS_FS_EXECUTE for layout1.execute. */
struct landlock_ruleset_attr ruleset_attr = {
.handled_access_fs = LANDLOCK_ACCESS_FS_EXECUTE,
};
int ruleset_fd = landlock_create_ruleset(&ruleset_attr,
sizeof(ruleset_attr), 0);
if (ruleset_fd < 0)
die("landlock_create_ruleset");
int parent_fd = open("repro-dir", O_PATH);
if (parent_fd < 0)
die("open repro-dir O_PATH");
struct landlock_path_beneath_attr path_beneath = {
.allowed_access = LANDLOCK_ACCESS_FS_EXECUTE,
.parent_fd = parent_fd,
};
if (landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
&path_beneath, 0) != 0)
die("landlock_add_rule");
close(parent_fd);
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0)
die("prctl(PR_SET_NO_NEW_PRIVS)");
if (landlock_restrict_self(ruleset_fd, 0) != 0)
die("landlock_restrict_self");
close(ruleset_fd);
printf("Landlock ruleset installed: EXECUTE-only, one PathBeneath "
"rule anchored on repro-dir (the target file's own parent).\n");
int result = try_execve("repro-dir/exe");
if (result == 0) {
printf("PASS: execve succeeded, as the upstream selftest "
"(layout1.execute, file1_s1d2 case) expects.\n");
} else {
printf("FAIL: execve was denied (EACCES) despite an "
"explicit, correctly-anchored PathBeneath rule "
"granting LANDLOCK_ACCESS_FS_EXECUTE on the file's "
"own parent directory -- this contradicts "
"tools/testing/selftests/landlock/fs_test.c's "
"TEST_F_FORK(layout1, execute) expectation for the "
"file1_s1d2 case.\n");
}
system("rm -rf repro-dir");
return result;
}
Build and run:
$ gcc -O0 -g -Wall -o repro repro.c
$ ./repro
Landlock ABI version: 9
Baseline (no Landlock): execve succeeded, as expected.
Landlock ruleset installed: EXECUTE-only, one PathBeneath rule anchored on repro-dir (the target file's own parent).
execve(repro-dir/exe) failed: Permission denied (errno 13)
FAIL: execve was denied (EACCES) despite an explicit, correctly-anchored PathBeneath rule granting LANDLOCK_ACCESS_FS_EXECUTE on the file's own parent directory -- this contradicts tools/testing/selftests/landlock/fs_test.c's TEST_F_FORK(layout1, execute) expectation for the file1_s1d2 case.
What was ruled out before concluding this is a kernel-level issue
--------------------------------------------------------------------
This was investigated extensively in the course of debugging a real
downstream project (a Rust codebase using the landlock crate 0.4.5) that
hit this exact denial. Before concluding it's a kernel bug rather than a
userspace mistake, the following were each tested and ruled out as the
cause:
1. SELinux: this host runs SELinux Enforcing, but the reproduction
above runs entirely under the interactive shell's unconfined_t
domain, and the identical target file executes fine via a plain
(non-Landlock) execve() beforehand in the same process. Only adding
the Landlock ruleset flips the result to EACCES.
2. IPE (Integrity Policy Enforcement): enforce=1 on this host, but
/sys/kernel/security/ipe/policies/ is empty (no policy loaded), and
no IPE-related denial appears in the audit log around the failure. A
plain execve() of the same file with no Landlock domain active
succeeds, which would not be the case if IPE were unconditionally
denying this file.
3. Kernel lockdown mode: active at "integrity" level on this host
(Fedora enables this automatically under Secure Boot), but lockdown's
documented restrictions (module signing, /dev/mem, hibernation,
kexec, debugfs, etc.) govern kernel-image-integrity operations, not
ordinary unprivileged LSM policy decisions like Landlock's own
filesystem checks, and no documented interaction between the two was
found.
4. tmpfs vs. a real on-disk filesystem: the denial reproduces
identically whether the target directory is on tmpfs (/tmp) or a
real on-disk btrfs filesystem (the root filesystem).
5. fd-based (execveat+AT_EMPTY_PATH) vs. path-based execve(): both
fail identically; this is not specific to executing via an
already-open file descriptor.
6. Direct child vs. nested subdirectory: a file nested one level deeper
than the anchored rule fails identically to a file directly in the
anchored directory.
7. O_PATH vs. plain open() for the rule's anchor fd: no difference
(the landlock Rust crate's own documentation warns plain File opens
"may lead to unexpected errors," but explicitly testing O_PATH
produced the identical denial).
8. Ruleset rights breadth: tested with handled_access_fs as EXECUTE-only
as the full V3-era 15-right set, and with an additional explicit
file-anchored rule (correctly scoped to file-valid rights) layered
alongside the directory rule. All identical.
9. landlock_ruleset_attr struct size: tested with the struct passed at
24, 32, 48, and 64 bytes (padded with zeroed trailing fields, in case
of an extensible-struct zero-extension gap for fields introduced at
ABI 8/9, e.g. the quiet_access_fs/quiet_access_net/quiet_scoped
fields added around ABI 7-9). No difference; the reproduction
attached uses sizeof(ruleset_attr) against the real system header,
matching upstream selftest convention exactly.
10. Published errata: checked all three currently-documented entries
in security/landlock/errata/ (disconnected-directory rename
widening, TCP socket protocol misclassification, thread signal
scoping). None match this symptom.
11. Direct read of security/landlock/fs.c on torvalds/linux master:
the is_access_to_paths_allowed()/current_check_access_path()/
hook_file_open() hierarchy-walk logic appears correct for this
simple case (walk starts at the target file's own dentry, checks
find_rule() at each level while walking up via dget_parent(), and
our anchor is exactly one level up). No obvious logic defect was
found by inspection, which is part of why this is being reported
rather than fixed downstream.
Given (11), if the master-branch logic is correct, this may already be
fixed in a tree newer than 7.1.3, or the regression window may be
narrow but as of this exact kernel, the discrepancy against the
selftest's own documented expectation is real and reproducible.
Impact
------
This affects any unprivileged (or privileged, self-restricting) process
that installs a minimal Landlock domain and then tries to execute a file
covered by a directory-anchored rule which is a common Landlock usage
pattern (matching the kernel's own selftest).
Downstream, it silently breaks a security-hardening code path
(Landlock-based filesystem confinement for a privileged process tree)
with no diagnostic beyond a generic EACCES, since the process attempting
the exec has already dropped privileges and cannot meaningfully report
the failure back to a parent through advanced means.
Request
-------
Could you confirm whether this is a known/already-fixed issue, and if
not, whether the attached reproduction is sufficient to track down the
regression? Let me know if you'd like me test a patch or provide more
instrumentation from this exact kernel build if useful.
Attachments
-----------
- repro.c - minimal standalone reproduction (also inlined above)
- official-selftest-output.log - full raw TAP output from running the
unmodified v7.1.3 fs_test -f layout1 -t execute against this kernel
[-- Attachment #1.1.2.1: Type: text/html, Size: 27985 bytes --]
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1.2: repro.c --]
[-- Type: text/x-csrc; filename="repro.c"; name="repro.c", Size: 5066 bytes --]
/*
* Minimal standalone reproduction of a Landlock EXECUTE-right denial that
* contradicts the upstream kernel's own selftest expectation.
*
* This mirrors tools/testing/selftests/landlock/fs_test.c's
* TEST_F_FORK(layout1, execute) -- specifically the file1_s1d2 case: a
* PathBeneath rule granting only LANDLOCK_ACCESS_FS_EXECUTE, anchored on a
* directory, is expected to permit execve() of a file directly inside that
* directory (upstream asserts test_execute(_metadata, 0, file1_s1d2), i.e.
* "no error"). On this kernel it is denied with EACCES instead.
*
* No root/CAP_SYS_ADMIN required -- Landlock is designed for unprivileged
* use, and this reproduces the same way as an ordinary user.
*
* Build: gcc -O0 -g -Wall -o repro repro.c
* Run: ./repro
*
* Observed on: Linux 7.1.3-200.fc44.x86_64 (Fedora 44 Workstation),
* Landlock ABI version 9 (per landlock_create_ruleset(NULL, 0,
* LANDLOCK_CREATE_RULESET_VERSION)).
*/
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <linux/landlock.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
static int landlock_create_ruleset(const struct landlock_ruleset_attr *attr,
size_t size, __u32 flags)
{
return syscall(SYS_landlock_create_ruleset, attr, size, flags);
}
static int landlock_add_rule(int ruleset_fd, enum landlock_rule_type type,
const void *attr, __u32 flags)
{
return syscall(SYS_landlock_add_rule, ruleset_fd, type, attr, flags);
}
static int landlock_restrict_self(int ruleset_fd, __u32 flags)
{
return syscall(SYS_landlock_restrict_self, ruleset_fd, flags);
}
static void die(const char *what)
{
fprintf(stderr, "%s: %s\n", what, strerror(errno));
exit(1);
}
/* Runs `path` via a fresh execve() in a child, prints and returns its result. */
static int try_execve(const char *path)
{
pid_t pid = fork();
if (pid < 0)
die("fork");
if (pid == 0) {
char *const argv[] = { (char *)path, NULL };
execve(path, argv, NULL);
/* Only reached on failure. */
fprintf(stderr, "execve(%s) failed: %s (errno %d)\n", path,
strerror(errno), errno);
_exit(1);
}
int status;
waitpid(pid, &status, 0);
if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
return 0;
return 1;
}
int main(void)
{
int abi = landlock_create_ruleset(NULL, 0,
LANDLOCK_CREATE_RULESET_VERSION);
printf("Landlock ABI version: %d\n", abi);
if (abi < 0)
die("landlock_create_ruleset(VERSION)");
/* Build tmp/dir/exe, matching layout1's dir_s1d2/file1_s1d2 shape:
* a rule anchored on the parent directory, target file directly
* inside it (zero levels of extra nesting). */
if (mkdir("repro-dir", 0700) < 0 && errno != EEXIST)
die("mkdir repro-dir");
/* Copy /bin/true in as our target executable. */
{
char cmd[256];
snprintf(cmd, sizeof(cmd),
"cp /bin/true repro-dir/exe && chmod 755 repro-dir/exe");
if (system(cmd) != 0)
die("cp /bin/true");
}
/* Baseline: confirm it executes fine before Landlock is involved. */
if (try_execve("repro-dir/exe") != 0) {
fprintf(stderr, "baseline execve failed even without Landlock -- "
"environment problem, not a Landlock issue\n");
return 1;
}
printf("Baseline (no Landlock): execve succeeded, as expected.\n");
/* Minimal ruleset: EXECUTE only, matching the official selftest's
* rules[0].access = LANDLOCK_ACCESS_FS_EXECUTE for layout1.execute. */
struct landlock_ruleset_attr ruleset_attr = {
.handled_access_fs = LANDLOCK_ACCESS_FS_EXECUTE,
};
int ruleset_fd = landlock_create_ruleset(&ruleset_attr,
sizeof(ruleset_attr), 0);
if (ruleset_fd < 0)
die("landlock_create_ruleset");
int parent_fd = open("repro-dir", O_PATH);
if (parent_fd < 0)
die("open repro-dir O_PATH");
struct landlock_path_beneath_attr path_beneath = {
.allowed_access = LANDLOCK_ACCESS_FS_EXECUTE,
.parent_fd = parent_fd,
};
if (landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
&path_beneath, 0) != 0)
die("landlock_add_rule");
close(parent_fd);
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0)
die("prctl(PR_SET_NO_NEW_PRIVS)");
if (landlock_restrict_self(ruleset_fd, 0) != 0)
die("landlock_restrict_self");
close(ruleset_fd);
printf("Landlock ruleset installed: EXECUTE-only, one PathBeneath "
"rule anchored on repro-dir (the target file's own parent).\n");
int result = try_execve("repro-dir/exe");
if (result == 0) {
printf("PASS: execve succeeded, as the upstream selftest "
"(layout1.execute, file1_s1d2 case) expects.\n");
} else {
printf("FAIL: execve was denied (EACCES) despite an "
"explicit, correctly-anchored PathBeneath rule "
"granting LANDLOCK_ACCESS_FS_EXECUTE on the file's "
"own parent directory -- this contradicts "
"tools/testing/selftests/landlock/fs_test.c's "
"TEST_F_FORK(layout1, execute) expectation for the "
"file1_s1d2 case.\n");
}
system("rm -rf repro-dir");
return result;
}
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1.3: official-selftest-output.log --]
[-- Type: text/x-log; filename="official-selftest-output.log"; name="official-selftest-output.log", Size: 9001 bytes --]
TAP version 13
1..68
# Starting 68 tests from 1 test cases.
# RUN layout1.no_restriction ...
# OK layout1.no_restriction
ok 1 layout1.no_restriction
# RUN layout1.inval ...
# OK layout1.inval
ok 2 layout1.inval
# RUN layout1.file_and_dir_access_rights ...
# OK layout1.file_and_dir_access_rights
ok 3 layout1.file_and_dir_access_rights
# RUN layout1.rule_with_unhandled_access ...
# OK layout1.rule_with_unhandled_access
ok 4 layout1.rule_with_unhandled_access
# RUN layout1.effective_access ...
# OK layout1.effective_access
ok 5 layout1.effective_access
# RUN layout1.unhandled_access ...
# OK layout1.unhandled_access
ok 6 layout1.unhandled_access
# RUN layout1.ruleset_overlap ...
# OK layout1.ruleset_overlap
ok 7 layout1.ruleset_overlap
# RUN layout1.layer_rule_unions ...
# OK layout1.layer_rule_unions
ok 8 layout1.layer_rule_unions
# RUN layout1.non_overlapping_accesses ...
# OK layout1.non_overlapping_accesses
ok 9 layout1.non_overlapping_accesses
# RUN layout1.interleaved_masked_accesses ...
# OK layout1.interleaved_masked_accesses
ok 10 layout1.interleaved_masked_accesses
# RUN layout1.inherit_subset ...
# OK layout1.inherit_subset
ok 11 layout1.inherit_subset
# RUN layout1.inherit_superset ...
# OK layout1.inherit_superset
ok 12 layout1.inherit_superset
# RUN layout1.empty_or_same_ruleset ...
# OK layout1.empty_or_same_ruleset
ok 13 layout1.empty_or_same_ruleset
# RUN layout1.rule_on_mountpoint ...
# OK layout1.rule_on_mountpoint
ok 14 layout1.rule_on_mountpoint
# RUN layout1.rule_over_mountpoint ...
# OK layout1.rule_over_mountpoint
ok 15 layout1.rule_over_mountpoint
# RUN layout1.rule_over_root_allow_then_deny ...
# OK layout1.rule_over_root_allow_then_deny
ok 16 layout1.rule_over_root_allow_then_deny
# RUN layout1.rule_over_root_deny ...
# OK layout1.rule_over_root_deny
ok 17 layout1.rule_over_root_deny
# RUN layout1.rule_inside_mount_ns ...
# OK layout1.rule_inside_mount_ns
ok 18 layout1.rule_inside_mount_ns
# RUN layout1.mount_and_pivot ...
# OK layout1.mount_and_pivot
ok 19 layout1.mount_and_pivot
# RUN layout1.move_mount ...
# OK layout1.move_mount
ok 20 layout1.move_mount
# RUN layout1.topology_changes_with_net_only ...
# OK layout1.topology_changes_with_net_only
ok 21 layout1.topology_changes_with_net_only
# RUN layout1.topology_changes_with_net_and_fs ...
# OK layout1.topology_changes_with_net_and_fs
ok 22 layout1.topology_changes_with_net_and_fs
# RUN layout1.release_inodes ...
# OK layout1.release_inodes
ok 23 layout1.release_inodes
# RUN layout1.covered_rule ...
# OK layout1.covered_rule
ok 24 layout1.covered_rule
# RUN layout1.relative_open ...
# OK layout1.relative_open
ok 25 layout1.relative_open
# RUN layout1.relative_chdir ...
# OK layout1.relative_chdir
ok 26 layout1.relative_chdir
# RUN layout1.relative_chroot_only ...
# OK layout1.relative_chroot_only
ok 27 layout1.relative_chroot_only
# RUN layout1.relative_chroot_chdir ...
# OK layout1.relative_chroot_chdir
ok 28 layout1.relative_chroot_chdir
# RUN layout1.execute ...
# fs_test.c:1949:execute:Expected err ? -1 : 0 (0) == execve(path, argv, NULL) (-1)
# fs_test.c:1951:execute:Failed to execute "tmp/s1d1/s1d2/f1": Permission denied
# execute: Test terminated by assertion
# FAIL layout1.execute
not ok 29 layout1.execute
# RUN layout1.umount_sandboxer ...
# fs_test.c:1929:umount_sandboxer:Expected 0 (0) <= src_fd (-1)
# fs_test.c:1931:umount_sandboxer:Failed to open "./sandbox-and-launch": No such file or directory
# umount_sandboxer: Test terminated by assertion
# FAIL layout1.umount_sandboxer
not ok 30 layout1.umount_sandboxer
# RUN layout1.link ...
# OK layout1.link
ok 31 layout1.link
# RUN layout1.rename_file ...
# OK layout1.rename_file
ok 32 layout1.rename_file
# RUN layout1.rename_dir ...
# OK layout1.rename_dir
ok 33 layout1.rename_dir
# RUN layout1.reparent_refer ...
# OK layout1.reparent_refer
ok 34 layout1.reparent_refer
# RUN layout1.refer_denied_by_default1 ...
# OK layout1.refer_denied_by_default1
ok 35 layout1.refer_denied_by_default1
# RUN layout1.refer_denied_by_default2 ...
# OK layout1.refer_denied_by_default2
ok 36 layout1.refer_denied_by_default2
# RUN layout1.refer_denied_by_default3 ...
# OK layout1.refer_denied_by_default3
ok 37 layout1.refer_denied_by_default3
# RUN layout1.refer_denied_by_default4 ...
# OK layout1.refer_denied_by_default4
ok 38 layout1.refer_denied_by_default4
# RUN layout1.refer_mount_root_deny ...
# OK layout1.refer_mount_root_deny
ok 39 layout1.refer_mount_root_deny
# RUN layout1.refer_part_mount_tree_is_allowed ...
# OK layout1.refer_part_mount_tree_is_allowed
ok 40 layout1.refer_part_mount_tree_is_allowed
# RUN layout1.reparent_link ...
# OK layout1.reparent_link
ok 41 layout1.reparent_link
# RUN layout1.reparent_rename ...
# OK layout1.reparent_rename
ok 42 layout1.reparent_rename
# RUN layout1.reparent_exdev_layers_rename1 ...
# OK layout1.reparent_exdev_layers_rename1
ok 43 layout1.reparent_exdev_layers_rename1
# RUN layout1.reparent_exdev_layers_rename2 ...
# OK layout1.reparent_exdev_layers_rename2
ok 44 layout1.reparent_exdev_layers_rename2
# RUN layout1.reparent_exdev_layers_exchange1 ...
# OK layout1.reparent_exdev_layers_exchange1
ok 45 layout1.reparent_exdev_layers_exchange1
# RUN layout1.reparent_exdev_layers_exchange2 ...
# OK layout1.reparent_exdev_layers_exchange2
ok 46 layout1.reparent_exdev_layers_exchange2
# RUN layout1.reparent_exdev_layers_exchange3 ...
# OK layout1.reparent_exdev_layers_exchange3
ok 47 layout1.reparent_exdev_layers_exchange3
# RUN layout1.reparent_remove ...
# OK layout1.reparent_remove
ok 48 layout1.reparent_remove
# RUN layout1.reparent_dom_superset ...
# OK layout1.reparent_dom_superset
ok 49 layout1.reparent_dom_superset
# RUN layout1.remove_dir ...
# OK layout1.remove_dir
ok 50 layout1.remove_dir
# RUN layout1.remove_file ...
# OK layout1.remove_file
ok 51 layout1.remove_file
# RUN layout1.make_char ...
# OK layout1.make_char
ok 52 layout1.make_char
# RUN layout1.make_block ...
# OK layout1.make_block
ok 53 layout1.make_block
# RUN layout1.make_reg_1 ...
# OK layout1.make_reg_1
ok 54 layout1.make_reg_1
# RUN layout1.make_reg_2 ...
# OK layout1.make_reg_2
ok 55 layout1.make_reg_2
# RUN layout1.make_sock ...
# OK layout1.make_sock
ok 56 layout1.make_sock
# RUN layout1.make_fifo ...
# OK layout1.make_fifo
ok 57 layout1.make_fifo
# RUN layout1.make_sym ...
# OK layout1.make_sym
ok 58 layout1.make_sym
# RUN layout1.make_dir ...
# OK layout1.make_dir
ok 59 layout1.make_dir
# RUN layout1.proc_unlinked_file ...
# OK layout1.proc_unlinked_file
ok 60 layout1.proc_unlinked_file
# RUN layout1.proc_pipe ...
# OK layout1.proc_pipe
ok 61 layout1.proc_pipe
# RUN layout1.truncate_unhandled ...
# OK layout1.truncate_unhandled
ok 62 layout1.truncate_unhandled
# RUN layout1.truncate ...
# OK layout1.truncate
ok 63 layout1.truncate
# RUN layout1.ftruncate ...
# OK layout1.ftruncate
ok 64 layout1.ftruncate
# RUN layout1.o_path_ftruncate_and_ioctl ...
# OK layout1.o_path_ftruncate_and_ioctl
ok 65 layout1.o_path_ftruncate_and_ioctl
# RUN layout1.blanket_permitted_ioctls ...
# OK layout1.blanket_permitted_ioctls
ok 66 layout1.blanket_permitted_ioctls
# RUN layout1.named_pipe_ioctl ...
# OK layout1.named_pipe_ioctl
ok 67 layout1.named_pipe_ioctl
# RUN layout1.named_unix_domain_socket_ioctl ...
# OK layout1.named_unix_domain_socket_ioctl
ok 68 layout1.named_unix_domain_socket_ioctl
# FAILED: 66 / 68 tests passed.
# Totals: pass:66 fail:2 xfail:0 xpass:0 skip:0 error:0
[-- Attachment #1.4: publickey - ken@kengrimes.com - 0xEDFCC5BC.asc --]
[-- Type: application/pgp-keys, Size: 645 bytes --]
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 343 bytes --]
^ permalink raw reply [flat|nested] 2+ messages in thread* Re: [BUG] Landlock denies LANDLOCK_ACCESS_FS_EXECUTE despite a correctly-anchored PathBeneath rule (contradicts selftest layout1.execute)
2026-07-14 21:07 [BUG] Landlock denies LANDLOCK_ACCESS_FS_EXECUTE despite a correctly-anchored PathBeneath rule (contradicts selftest layout1.execute) Ken Grimes
@ 2026-07-15 8:39 ` Günther Noack
0 siblings, 0 replies; 2+ messages in thread
From: Günther Noack @ 2026-07-15 8:39 UTC (permalink / raw)
To: Ken Grimes
Cc: linux-security-module@vger.kernel.org, Mickaël Salaün,
landlock
Hello Ken!
(Also adding landlock@lists.linux.dev to CC)
On Tue, Jul 14, 2026 at 09:07:56PM +0000, Ken Grimes wrote:
> Hey all, this is my first bug report for linux. The issue was discovered
> alongside llm-assisted coding on a downstream project. The
> investigation/testing of the bug was a mostly manual process so I could
> be sure this was something real. Please let me know if I can provide any
> further details or assistance. Hope this is helpful, thank you for all of your
> hard work!
Welcome and thanks for reporting your first issue!
I believe the issue you are observing is that the /bin/true program you are
starting is a dynamically linked executable. As such, executing it requires
both the LANDLOCK_ACCESS_FS_EXECUTE right on the binary itself and on
the system's dynamic loader binary, which usually lives in /lib/ld-linux.so.*
(but there are symlinks and 32/64-bit differences at play as well, which
influence the actual final location).
You can try this out with the following experiments:
(1) Compile a "true" program statically and try using that:
$ echo 'int main() { return 0; }' > true.c
$ CFLAGS=-static make true
This can be started with the test you have,
unlike the dynamically linked version.
(2) Alternatively, add execute permissions for the dynamic loader:
Add an additional "path beneath" rule that allow-lists the execution
access right on /lib/ld-linux.so.2, /lib64/ld-linux-x86-64.so.2 or
wherever else your dynamic loader is. (You can discover the actual
location using "ldd /bin/true".)
With either one of these two changes, your standalone reproducer program
starts working again. Or at least it does on my machine. If it still doesn't
work on your end that way, please let us know. :)
I admit that we should probably point this out in the Landlock documentation
for the LANDLOCK_ACCESS_FS_EXECUTE right, as dynamic linking is common and it
is a potential issue that many people might run into.
For background on the dynamic loading mechanism, see the man page ld.so(8) [1]
and the LWN article "How programs get run: ELF binaries" [2] (specifically the
section "Dynamically linked programs").
—Günther
[1] https://man7.org/linux/man-pages/man8/ld.so.8.html
[2] https://lwn.net/Articles/631631/
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-07-15 8:39 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-07-14 21:07 [BUG] Landlock denies LANDLOCK_ACCESS_FS_EXECUTE despite a correctly-anchored PathBeneath rule (contradicts selftest layout1.execute) Ken Grimes
2026-07-15 8:39 ` Günther Noack
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.