* [PATCH v3 0/6] Fix Landlock mediation of commoncap's capability checks
@ 2026-11-18 14:52 Mickaël Salaün
2026-11-18 14:52 ` [PATCH v3 1/6] landlock: Factor out capability denial checks Mickaël Salaün
` (5 more replies)
0 siblings, 6 replies; 13+ messages in thread
From: Mickaël Salaün @ 2026-11-18 14:52 UTC (permalink / raw)
To: Günther Noack
Cc: Mickaël Salaün, Ada Smith, Hungyu Lin, James Morris,
Josef Bacik, Paul Moore, Serge Hallyn, Serge Hallyn, kernel-team,
linux-kernel, linux-security-module
Hi,
This is series 1 of 3:
* 1. fix Landlock mediation of commoncap's capability checks;
2. fix PR_SET_SECUREBITS mediation and add focused Landlock tests;
3. fix Landlock mediation of capabilities guarding LSM policies.
LANDLOCK_PERMISSION_CAPABILITY_USE, merged for v7.4, denies capabilities
through the LSM capable hook, but commoncap's mmap_addr, capset and
vm_enough_memory hooks call cap_capable() directly. A domain that
denies a capability can therefore still:
- map memory below vm.mmap_min_addr (CAP_SYS_RAWIO), which defeats a
mitigation for kernel NULL pointer dereferences;
- add inheritable capabilities outside of its inheritable and permitted
sets (CAP_SETPCAP), which lets a privileged sandbox without no_new_privs
gain capabilities through execve(), although the domain still
restricts their use;
- use the admin memory reserve with vm.overcommit_memory=2
(CAP_SYS_ADMIN).
As SELinux does, patches 2 to 4 add Landlock's own check to these hooks,
with commoncap's conditions, so they only deny what commoncap granted
because of the capability. Patch 1 factors out the shared check. Patch
5 adds tests, including audit tests, that fail without the mmap_addr and
capset fixes; testing the admin reserve would require changing
system-wide overcommit settings. Patch 6 fixes the documentation, which
overstated what the permission restricts and how its denials show.
Two other direct capability-set checks are fixed separately:
- PSI triggers (CAP_SYS_RESOURCE):
https://patch.msgid.link/20261106120004.90041-1-dennylin0707@gmail.com
- user namespace uid 0 mapping (CAP_SETFCAP):
https://patch.msgid.link/20261110144205.2404088-1-mic@digikod.net
Changes since v2:
https://patch.msgid.link/20261117101157.2520463-1-mic@digikod.net
- Use ASSERT_*() in the tests where later checks depend on the result,
and rename a test helper parameter (suggested by Günther Noack).
- Describe the capset hook's condition from cap_capset()'s point of view
(suggested by Günther Noack).
- Shorten the commit messages (suggested by Günther Noack).
- Reword the capability permission's UAPI description (suggested by
Günther Noack).
- Add Günther Noack's Reviewed-by.
Changes since v1:
https://patch.msgid.link/20261110202436.2408244-1-mic@digikod.net
- Replace the admin reserve test, which changed system-wide overcommit
settings and was racy, with a comment, and fix the mmap_addr tests on
32-bit ARM (reported by Sashiko).
- Add Serge Hallyn's Acked-by.
Regards,
Mickaël Salaün (6):
landlock: Factor out capability denial checks
landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr
landlock: Mediate CAP_SETPCAP for inheritable capabilities
landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve
selftests/landlock: Test capability checks outside the capable hook
landlock: Fix capability restriction documentation
Documentation/security/landlock.rst | 8 +-
Documentation/userspace-api/landlock.rst | 8 +-
include/uapi/linux/landlock.h | 7 +-
security/landlock/cap.c | 111 ++++++-
tools/testing/selftests/landlock/cap_test.c | 328 ++++++++++++++++++++
tools/testing/selftests/landlock/common.h | 4 +-
6 files changed, 444 insertions(+), 22 deletions(-)
base-commit: 7475ea8b58616b33c04afb976cf0fbaad9dd63fb
--
2.56.0
^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH v3 1/6] landlock: Factor out capability denial checks
2026-11-18 14:52 [PATCH v3 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
@ 2026-11-18 14:52 ` Mickaël Salaün
2026-11-18 14:55 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 2/6] landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr Mickaël Salaün
` (4 subsequent siblings)
5 siblings, 1 reply; 13+ messages in thread
From: Mickaël Salaün @ 2026-11-18 14:52 UTC (permalink / raw)
To: Günther Noack
Cc: Mickaël Salaün, Ada Smith, Hungyu Lin, James Morris,
Josef Bacik, Paul Moore, Serge Hallyn, Serge Hallyn, kernel-team,
linux-kernel, linux-security-module
commoncap also makes capability decisions from LSM hooks other than
capable, and the following commits add Landlock counterparts for them.
Move the check and its denial logging from hook_capable() into
check_cap() so that these hooks share it.
No functional change.
Cc: Günther Noack <gnoack@google.com>
Acked-by: Serge Hallyn (AMD) <sergeh@kernel.org>
Reviewed-by: Günther Noack <gnoack@google.com>
Signed-off-by: Mickaël Salaün <mic@digikod.net>
---
Changes since v2:
https://patch.msgid.link/20261117101157.2520463-2-mic@digikod.net
- Shorten the commit message.
- Add Günther Noack's Reviewed-by.
Changes since v1:
https://patch.msgid.link/20261110202436.2408244-2-mic@digikod.net
- Add Serge Hallyn's Acked-by.
---
security/landlock/cap.c | 36 +++++++++++++++++++++++++++---------
1 file changed, 27 insertions(+), 9 deletions(-)
diff --git a/security/landlock/cap.c b/security/landlock/cap.c
index b4f491b09baa..fa59118e3486 100644
--- a/security/landlock/cap.c
+++ b/security/landlock/cap.c
@@ -24,25 +24,21 @@ static const struct access_masks cap_permission = {
};
/**
- * hook_capable - Deny capability use for Landlock-sandboxed processes
+ * check_cap - Check a capability use against the domain of @cred
*
* @cred: Credentials being checked.
- * @ns: Target user namespace (intentionally ignored; policy depends on the
- * acting credentials and @cap, not namespace ownership).
* @cap: Capability number (CAP_*).
* @opts: Capability check options. CAP_OPT_NOAUDIT skips the denial record:
* no audit record, no trace event, and no denial count.
*
* Pure bitmask check: denies the capability if it is not in the layer's allowed
- * set. This hook is purely restrictive: commoncap is registered with
- * LSM_ORDER_FIRST so cap_capable() always runs first, which means Landlock can
- * deny capabilities that commoncap would allow, but never grant capabilities
- * that commoncap denied.
+ * set. It does not check that @cred holds @cap: only call it for a capability
+ * that commoncap already granted.
*
* Return: 0 if allowed, -EPERM if capability use is denied.
*/
-static int hook_capable(const struct cred *cred, struct user_namespace *ns,
- int cap, unsigned int opts)
+static int check_cap(const struct cred *const cred, const int cap,
+ const unsigned int opts)
{
const struct landlock_cred_security *subject;
size_t denied_layer;
@@ -72,6 +68,28 @@ static int hook_capable(const struct cred *cred, struct user_namespace *ns,
return -EPERM;
}
+/**
+ * hook_capable - Deny capability use for Landlock-sandboxed processes
+ *
+ * @cred: Credentials being checked.
+ * @ns: Target user namespace (intentionally ignored; policy depends on the
+ * acting credentials and @cap, not namespace ownership).
+ * @cap: Capability number (CAP_*).
+ * @opts: Capability check options, see check_cap().
+ *
+ * This hook is purely restrictive: commoncap is registered with LSM_ORDER_FIRST
+ * so cap_capable() always runs first, which means Landlock can deny
+ * capabilities that commoncap would allow, but never grant capabilities that
+ * commoncap denied.
+ *
+ * Return: 0 if allowed, -EPERM if capability use is denied.
+ */
+static int hook_capable(const struct cred *cred, struct user_namespace *ns,
+ int cap, unsigned int opts)
+{
+ return check_cap(cred, cap, opts);
+}
+
static struct security_hook_list landlock_hooks[] __ro_after_init = {
LSM_HOOK_INIT(capable, hook_capable),
};
--
2.56.0
^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH v3 2/6] landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr
2026-11-18 14:52 [PATCH v3 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
2026-11-18 14:52 ` [PATCH v3 1/6] landlock: Factor out capability denial checks Mickaël Salaün
@ 2026-11-18 14:52 ` Mickaël Salaün
2026-11-18 14:57 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 3/6] landlock: Mediate CAP_SETPCAP for inheritable capabilities Mickaël Salaün
` (3 subsequent siblings)
5 siblings, 1 reply; 13+ messages in thread
From: Mickaël Salaün @ 2026-11-18 14:52 UTC (permalink / raw)
To: Günther Noack
Cc: Mickaël Salaün, Ada Smith, Hungyu Lin, James Morris,
Josef Bacik, Paul Moore, Serge Hallyn, Serge Hallyn, kernel-team,
linux-kernel, linux-security-module
commoncap's mmap_addr hook checks CAP_SYS_RAWIO for mappings below
vm.mmap_min_addr with cap_capable(), which skips the capable hook, so a
domain denying CAP_SYS_RAWIO cannot prevent these mappings. Mapping the
lowest pages helps to exploit kernel NULL pointer dereferences.
Add a Landlock mmap_addr hook that checks CAP_SYS_RAWIO against the
domain under the same condition, as SELinux checks its own mmap_zero
permission in this hook. commoncap runs first, so the hook only sees
mappings that commoncap allowed. This also covers the x86 vm86(2) and
vm86old(2) system calls. Calling capable() from cap_mmap_addr() would
instead expose this check to the capable hook of all LSMs.
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>
Reviewed-by: Günther Noack <gnoack@google.com>
Fixes: 97c8386f1d74 ("landlock: Enforce capability restrictions")
Signed-off-by: Mickaël Salaün <mic@digikod.net>
---
Changes since v2:
https://patch.msgid.link/20261117101157.2520463-3-mic@digikod.net
- Shorten the commit message (suggested by Günther Noack).
- Add Günther Noack's Reviewed-by.
Changes since v1:
https://patch.msgid.link/20261110202436.2408244-3-mic@digikod.net
- Add Serge Hallyn's Acked-by.
---
security/landlock/cap.c | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/security/landlock/cap.c b/security/landlock/cap.c
index fa59118e3486..10e1ca772b9c 100644
--- a/security/landlock/cap.c
+++ b/security/landlock/cap.c
@@ -9,6 +9,7 @@
#include <linux/cred.h>
#include <linux/lsm_audit.h>
#include <linux/lsm_hooks.h>
+#include <linux/security.h>
#include <uapi/linux/landlock.h>
#include "cap.h"
@@ -90,8 +91,29 @@ static int hook_capable(const struct cred *cred, struct user_namespace *ns,
return check_cap(cred, cap, opts);
}
+/**
+ * hook_mmap_addr - Restrict mappings below dac_mmap_min_addr
+ *
+ * @addr: Address of the new mapping.
+ *
+ * cap_mmap_addr() requires CAP_SYS_RAWIO to map below dac_mmap_min_addr, but
+ * calls cap_capable() directly, which skips hook_capable(). Check the same
+ * condition against the domain. commoncap runs first, so this only sees
+ * mappings that commoncap allowed.
+ *
+ * Return: 0 if allowed, -EPERM if CAP_SYS_RAWIO use is denied.
+ */
+static int hook_mmap_addr(unsigned long addr)
+{
+ if (addr >= dac_mmap_min_addr)
+ return 0;
+
+ return check_cap(current_cred(), CAP_SYS_RAWIO, CAP_OPT_NONE);
+}
+
static struct security_hook_list landlock_hooks[] __ro_after_init = {
LSM_HOOK_INIT(capable, hook_capable),
+ LSM_HOOK_INIT(mmap_addr, hook_mmap_addr),
};
__init void landlock_add_cap_hooks(void)
--
2.56.0
^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH v3 3/6] landlock: Mediate CAP_SETPCAP for inheritable capabilities
2026-11-18 14:52 [PATCH v3 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
2026-11-18 14:52 ` [PATCH v3 1/6] landlock: Factor out capability denial checks Mickaël Salaün
2026-11-18 14:52 ` [PATCH v3 2/6] landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr Mickaël Salaün
@ 2026-11-18 14:52 ` Mickaël Salaün
2026-11-18 14:58 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 4/6] landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve Mickaël Salaün
` (2 subsequent siblings)
5 siblings, 1 reply; 13+ messages in thread
From: Mickaël Salaün @ 2026-11-18 14:52 UTC (permalink / raw)
To: Günther Noack
Cc: Mickaël Salaün, Ada Smith, Hungyu Lin, James Morris,
Josef Bacik, Paul Moore, Serge Hallyn, Serge Hallyn, kernel-team,
linux-kernel, linux-security-module
cap_capset() checks CAP_SETPCAP with cap_capable() (through
cap_inh_is_capped()), which skips the capable hook, so a domain denying
CAP_SETPCAP cannot prevent adding capabilities outside of the old
inheritable and permitted sets to the inheritable set. Without
no_new_privs (possible when a task with CAP_SYS_ADMIN enforced the
domain), file inheritable capabilities can then grant permitted
capabilities on execve().
Add a Landlock capset hook that checks CAP_SETPCAP against the domain
under the same condition, as SELinux checks its own setcap permission in
this hook.
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>
Reviewed-by: Günther Noack <gnoack@google.com>
Fixes: 97c8386f1d74 ("landlock: Enforce capability restrictions")
Signed-off-by: Mickaël Salaün <mic@digikod.net>
---
Changes since v2:
https://patch.msgid.link/20261117101157.2520463-4-mic@digikod.net
- Describe the hook's condition from cap_capset()'s point of view in its
comment (suggested by Günther Noack).
- Shorten the commit message.
- Add Günther Noack's Reviewed-by.
Changes since v1:
https://patch.msgid.link/20261110202436.2408244-4-mic@digikod.net
- Add Serge Hallyn's Acked-by.
---
security/landlock/cap.c | 31 +++++++++++++++++++++++++++++++
1 file changed, 31 insertions(+)
diff --git a/security/landlock/cap.c b/security/landlock/cap.c
index 10e1ca772b9c..cdb95b979eaa 100644
--- a/security/landlock/cap.c
+++ b/security/landlock/cap.c
@@ -91,6 +91,36 @@ static int hook_capable(const struct cred *cred, struct user_namespace *ns,
return check_cap(cred, cap, opts);
}
+/**
+ * hook_capset - Restrict inheritable capability changes
+ *
+ * @new: New credentials (unused).
+ * @old: Current credentials.
+ * @effective: New effective set (unused).
+ * @inheritable: New inheritable set.
+ * @permitted: New permitted set (unused).
+ *
+ * cap_capset() denies a new inheritable set that is not a subset of the old
+ * inheritable and permitted sets, unless cap_inh_is_capped() finds CAP_SETPCAP.
+ * This check uses cap_capable(), which skips hook_capable(). commoncap runs
+ * first, so such a set reaching this hook means that commoncap granted
+ * CAP_SETPCAP: check it against the domain. capset(2) discards @new if this
+ * hook fails, so nothing is committed.
+ *
+ * Return: 0 if allowed, -EPERM if CAP_SETPCAP use is denied.
+ */
+static int hook_capset(struct cred *new, const struct cred *old,
+ const kernel_cap_t *effective,
+ const kernel_cap_t *inheritable,
+ const kernel_cap_t *permitted)
+{
+ if (cap_issubset(*inheritable,
+ cap_combine(old->cap_inheritable, old->cap_permitted)))
+ return 0;
+
+ return check_cap(old, CAP_SETPCAP, CAP_OPT_NONE);
+}
+
/**
* hook_mmap_addr - Restrict mappings below dac_mmap_min_addr
*
@@ -113,6 +143,7 @@ static int hook_mmap_addr(unsigned long addr)
static struct security_hook_list landlock_hooks[] __ro_after_init = {
LSM_HOOK_INIT(capable, hook_capable),
+ LSM_HOOK_INIT(capset, hook_capset),
LSM_HOOK_INIT(mmap_addr, hook_mmap_addr),
};
--
2.56.0
^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH v3 4/6] landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve
2026-11-18 14:52 [PATCH v3 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
` (2 preceding siblings ...)
2026-11-18 14:52 ` [PATCH v3 3/6] landlock: Mediate CAP_SETPCAP for inheritable capabilities Mickaël Salaün
@ 2026-11-18 14:52 ` Mickaël Salaün
2026-11-18 14:56 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 5/6] selftests/landlock: Test capability checks outside the capable hook Mickaël Salaün
2026-11-18 14:52 ` [PATCH v3 6/6] landlock: Fix capability restriction documentation Mickaël Salaün
5 siblings, 1 reply; 13+ messages in thread
From: Mickaël Salaün @ 2026-11-18 14:52 UTC (permalink / raw)
To: Günther Noack
Cc: Mickaël Salaün, Ada Smith, Hungyu Lin, James Morris,
Josef Bacik, Paul Moore, Serge Hallyn, Serge Hallyn, kernel-team,
linux-kernel, linux-security-module
With vm.overcommit_memory=2, __vm_enough_memory() keeps the admin
reserve for callers with CAP_SYS_ADMIN, which cap_vm_enough_memory()
checks with cap_capable(), so a domain denying CAP_SYS_ADMIN cannot
withhold this reserve, meant for an administrator to recover from memory
exhaustion.
Add a Landlock vm_enough_memory hook that withholds the reserve when the
domain denies CAP_SYS_ADMIN. Like commoncap and SELinux, do not audit
this check: it runs for every accounted mapping and only selects a
limit.
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>
Reviewed-by: Günther Noack <gnoack@google.com>
Fixes: 97c8386f1d74 ("landlock: Enforce capability restrictions")
Signed-off-by: Mickaël Salaün <mic@digikod.net>
---
Changes since v2:
https://patch.msgid.link/20261117101157.2520463-5-mic@digikod.net
- Shorten the commit message.
- Add Günther Noack's Reviewed-by.
Changes since v1:
https://patch.msgid.link/20261110202436.2408244-5-mic@digikod.net
- Add Serge Hallyn's Acked-by.
---
security/landlock/cap.c | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/security/landlock/cap.c b/security/landlock/cap.c
index cdb95b979eaa..caf514be3df0 100644
--- a/security/landlock/cap.c
+++ b/security/landlock/cap.c
@@ -141,10 +141,32 @@ static int hook_mmap_addr(unsigned long addr)
return check_cap(current_cred(), CAP_SYS_RAWIO, CAP_OPT_NONE);
}
+/**
+ * hook_vm_enough_memory - Restrict the admin memory reserve
+ *
+ * @mm: Address space being charged (unused).
+ * @pages: Number of pages being charged (unused).
+ *
+ * cap_vm_enough_memory() lets CAP_SYS_ADMIN use the vm.admin_reserve_kbytes
+ * reserve, but calls cap_capable() directly, which skips hook_capable(). Check
+ * the same capability against the domain. commoncap runs first, so this only
+ * sees tasks that commoncap let use the reserve. Like commoncap, do not log
+ * denials: this only selects a memory limit.
+ *
+ * Return: 0 if the domain does not withhold the reserve, -EPERM if
+ * CAP_SYS_ADMIN use is denied. An error does not fail the allocation by
+ * itself, but without the reserve, the allocation may fail with -ENOMEM.
+ */
+static int hook_vm_enough_memory(struct mm_struct *mm, long pages)
+{
+ return check_cap(current_cred(), CAP_SYS_ADMIN, CAP_OPT_NOAUDIT);
+}
+
static struct security_hook_list landlock_hooks[] __ro_after_init = {
LSM_HOOK_INIT(capable, hook_capable),
LSM_HOOK_INIT(capset, hook_capset),
LSM_HOOK_INIT(mmap_addr, hook_mmap_addr),
+ LSM_HOOK_INIT(vm_enough_memory, hook_vm_enough_memory),
};
__init void landlock_add_cap_hooks(void)
--
2.56.0
^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH v3 5/6] selftests/landlock: Test capability checks outside the capable hook
2026-11-18 14:52 [PATCH v3 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
` (3 preceding siblings ...)
2026-11-18 14:52 ` [PATCH v3 4/6] landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve Mickaël Salaün
@ 2026-11-18 14:52 ` Mickaël Salaün
2026-11-18 14:58 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 6/6] landlock: Fix capability restriction documentation Mickaël Salaün
5 siblings, 1 reply; 13+ messages in thread
From: Mickaël Salaün @ 2026-11-18 14:52 UTC (permalink / raw)
To: Günther Noack
Cc: Mickaël Salaün, Ada Smith, Hungyu Lin, James Morris,
Josef Bacik, Paul Moore, Serge Hallyn, Serge Hallyn, kernel-team,
linux-kernel, linux-security-module
Test the commoncap checks that the previous commits make Landlock
restrict: mapping below vm.mmap_min_addr (CAP_SYS_RAWIO) and adding
inheritable capabilities (CAP_SETPCAP). Each test checks that the
operation needs the capability, then runs it with the capability in four
variants: unsandboxed, denied, allowed and unhandled. The mmap_addr
tests skip if the architecture rejects the low page before the hook
(e.g. 32-bit ARM).
Audit tests check that these denials are logged, and that the admin
reserve check and allowed uses are not. The admin reserve has no
functional test because it depends on vm.overcommit_memory=2, a
system-wide setting.
Add CAP_SETPCAP and CAP_SYS_RAWIO to the capabilities that the tests may
raise.
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 v2:
https://patch.msgid.link/20261117101157.2520463-6-mic@digikod.net
- Use ASSERT_*() for results that later checks depend on (errno, audit
records, mappings), and drop the cleanup of the test mappings
(suggested by Günther Noack).
- Rename the is_allowed parameter of create_variant_ruleset() to
allow_cap (suggested by Günther Noack).
- Shorten the commit message.
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 | 328 ++++++++++++++++++++
tools/testing/selftests/landlock/common.h | 4 +-
2 files changed, 331 insertions(+), 1 deletion(-)
diff --git a/tools/testing/selftests/landlock/cap_test.c b/tools/testing/selftests/landlock/cap_test.c
index 3d7fd02e21ed..7c58ece1c6f0 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,247 @@ 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 @allow_cap,
+ * 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 allow_cap,
+ const int cap)
+{
+ 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 || !allow_cap)
+ 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);
+ ASSERT_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) {
+ ASSERT_EQ(low_page, addr)
+ {
+ TH_LOG("Failed to map below vm.mmap_min_addr: %s",
+ strerror(errno));
+ }
+ } else {
+ ASSERT_EQ(MAP_FAILED, addr);
+ EXPECT_EQ(EPERM, errno);
+ }
+ 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);
+
+ ASSERT_EQ(-1, add_inheritable_cap(CAP_NET_RAW));
+ EXPECT_EQ(EPERM, errno);
+
+ 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 {
+ ASSERT_EQ(-1, add_inheritable_cap(CAP_NET_RAW));
+ EXPECT_EQ(EPERM, errno);
+ }
+ 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 +1071,91 @@ 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);
+ ASSERT_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);
+ ASSERT_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);
+ ASSERT_NE(MAP_FAILED, addr);
+ clear_cap(_metadata, CAP_SYS_ADMIN);
+
+ ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
+ EXPECT_EQ(0, records.access);
+ EXPECT_EQ(0, records.domain);
+}
+
+/* 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);
+ ASSERT_EQ(low_page, addr);
+ clear_cap(_metadata, CAP_SYS_RAWIO);
+ }
+
+ ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
+ EXPECT_EQ(0, records.access);
+}
+
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
^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH v3 6/6] landlock: Fix capability restriction documentation
2026-11-18 14:52 [PATCH v3 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
` (4 preceding siblings ...)
2026-11-18 14:52 ` [PATCH v3 5/6] selftests/landlock: Test capability checks outside the capable hook Mickaël Salaün
@ 2026-11-18 14:52 ` Mickaël Salaün
2026-11-18 14:55 ` sashiko-bot
5 siblings, 1 reply; 13+ messages in thread
From: Mickaël Salaün @ 2026-11-18 14:52 UTC (permalink / raw)
To: Günther Noack
Cc: Mickaël Salaün, Ada Smith, Hungyu Lin, James Morris,
Josef Bacik, Paul Moore, Serge Hallyn, Serge Hallyn, kernel-team,
linux-kernel, linux-security-module
Some documented claims about LANDLOCK_PERMISSION_CAPABILITY_USE do not
hold for every capability check. Remove them instead of listing their
exceptions, and stop calling this permission a hook.
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>
Reviewed-by: Günther Noack <gnoack@google.com>
Fixes: 97c8386f1d74 ("landlock: Enforce capability restrictions")
Signed-off-by: Mickaël Salaün <mic@digikod.net>
---
Changes since v2:
https://patch.msgid.link/20261117101157.2520463-7-mic@digikod.net
- Describe the permission as only reducing the capabilities that
processes can use (suggested by Günther Noack).
- Add Günther Noack's Reviewed-by.
Changes since v1:
https://patch.msgid.link/20261110202436.2408244-7-mic@digikod.net
- Add Serge Hallyn's Acked-by.
---
Documentation/security/landlock.rst | 8 ++++----
Documentation/userspace-api/landlock.rst | 8 ++++----
include/uapi/linux/landlock.h | 7 +++----
3 files changed, 11 insertions(+), 12 deletions(-)
diff --git a/Documentation/security/landlock.rst b/Documentation/security/landlock.rst
index d81f1c2cd236..98c2e7139e8d 100644
--- a/Documentation/security/landlock.rst
+++ b/Documentation/security/landlock.rst
@@ -8,7 +8,7 @@ Landlock LSM: kernel documentation
==================================
:Author: Mickaël Salaün
-:Date: October 2026
+:Date: November 2026
Landlock's goal is to create scoped access-control (i.e. sandboxing). To
harden a whole system, this feature should be available to any process,
@@ -359,9 +359,9 @@ framework in ``log.c``, compiled under ``CONFIG_SECURITY_LANDLOCK_LOG``
(automatically selected by ``CONFIG_AUDIT`` or ``CONFIG_TRACEPOINTS``).
Audit records respect audit configuration, the domain's Landlock log
-flags, and ``LANDLOCK_LOG_DISABLED``. Tracepoints fire unconditionally,
-independent of these settings. The denial counter (``num_denials``) is
-always incremented regardless of logging configuration.
+flags, and ``LANDLOCK_LOG_DISABLED``. Tracepoints fire independently of
+these settings. The denial counter (``num_denials``) is
+incremented regardless of logging configuration.
Each denial tracepoint carries a ``logged`` field reporting the
audit-logging verdict: whether the denial would be written to the audit
diff --git a/Documentation/userspace-api/landlock.rst b/Documentation/userspace-api/landlock.rst
index 3d45b956b640..d00e94d8ed37 100644
--- a/Documentation/userspace-api/landlock.rst
+++ b/Documentation/userspace-api/landlock.rst
@@ -8,7 +8,7 @@ Landlock: unprivileged access control
=====================================
:Author: Mickaël Salaün
-:Date: October 2026
+:Date: November 2026
The goal of Landlock is to enable restriction of ambient rights (e.g. global
filesystem or network access) for a set of processes. Because Landlock
@@ -532,7 +532,7 @@ acquisition via :manpage:`open_tree(2)` / :manpage:`fsmount(2)`. Namespaces
the process is already a member of when the domain is enforced are implicitly
allowed (the process could not continue running otherwise); rules describe
which new namespace types the process may acquire.
-``LANDLOCK_PERMISSION_CAPABILITY_USE`` gates every exercise of a capability
+``LANDLOCK_PERMISSION_CAPABILITY_USE`` gates the exercise of capabilities
after the domain is enforced, regardless
of how the capability was obtained (inherited credentials, ``CLONE_NEWUSER``
grant, ``setuid``/file-cap-bearing :manpage:`execve(2)`, etc.). Configuring
@@ -641,9 +641,9 @@ after a domain is enforced through user namespace entry or :manpage:`capset(2)`;
privileged sandboxes that did not set ``PR_SET_NO_NEW_PRIVS`` may also gain
capabilities through :manpage:`execve(2)` of binaries with file capabilities.
In all cases, :manpage:`capget(2)` will report the credential's capability sets,
-but any denied capability will fail with ``EPERM`` when exercised. Do not rely
+but any denied capability will fail when exercised. Do not rely
on :manpage:`capget(2)` to determine whether the policy permits a given
-capability; only the actual operation will return ``EPERM`` upon denial.
+capability.
Truncating files
----------------
diff --git a/include/uapi/linux/landlock.h b/include/uapi/linux/landlock.h
index 24510e5d8479..558a610baea5 100644
--- a/include/uapi/linux/landlock.h
+++ b/include/uapi/linux/landlock.h
@@ -622,10 +622,9 @@ struct landlock_capability_attr {
* - %LANDLOCK_PERMISSION_CAPABILITY_USE: Restrict the use of specific Linux
* capabilities. A process in a Landlock domain that handles this permission
* is denied from exercising capabilities that are not explicitly allowed by a
- * %LANDLOCK_RULE_CAPABILITY rule. This hook is purely restrictive: it can
- * deny capabilities that the kernel would otherwise grant, but it can never
- * grant capabilities that the kernel already denied. Support added in
- * Landlock ABI version 12.
+ * %LANDLOCK_RULE_CAPABILITY rule. Landlock only reduces the capabilities
+ * that processes can use: it does not let them use capabilities that they
+ * would not have without Landlock. Support added in Landlock ABI version 12.
*/
#define LANDLOCK_PERMISSION_NAMESPACE_USE (1ULL << 0)
#define LANDLOCK_PERMISSION_CAPABILITY_USE (1ULL << 1)
--
2.56.0
^ permalink raw reply related [flat|nested] 13+ messages in thread
* Re: [PATCH v3 1/6] landlock: Factor out capability denial checks
2026-11-18 14:52 ` [PATCH v3 1/6] landlock: Factor out capability denial checks Mickaël Salaün
@ 2026-11-18 14:55 ` sashiko-bot
0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-18 14:55 UTC (permalink / raw)
Cc: linux-security-module
> commoncap also makes capability decisions from LSM hooks other than
> capable, and the following commits add Landlock counterparts for them.
> Move the check and its denial logging from hook_capable() into
> check_cap() so that these hooks share it.
>
> No functional change.
>
> Cc: Günther Noack <gnoack@google.com>
> Acked-by: Serge Hallyn (AMD) <sergeh@kernel.org>
> Reviewed-by: Günther Noack <gnoack@google.com>
> Signed-off-by: Mickaël Salaün <mic@digikod.net>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261118145217.2551053-1-mic@digikod.net?part=1
^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH v3 6/6] landlock: Fix capability restriction documentation
2026-11-18 14:52 ` [PATCH v3 6/6] landlock: Fix capability restriction documentation Mickaël Salaün
@ 2026-11-18 14:55 ` sashiko-bot
0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-18 14:55 UTC (permalink / raw)
Cc: linux-security-module
> Some documented claims about LANDLOCK_PERMISSION_CAPABILITY_USE do not
> hold for every capability check. Remove them instead of listing their
> exceptions, and stop calling this permission a hook.
>
> 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>
> Reviewed-by: Günther Noack <gnoack@google.com>
> Fixes: 97c8386f1d74 ("landlock: Enforce capability restrictions")
> Signed-off-by: Mickaël Salaün <mic@digikod.net>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261118145217.2551053-1-mic@digikod.net?part=6
^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH v3 4/6] landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve
2026-11-18 14:52 ` [PATCH v3 4/6] landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve Mickaël Salaün
@ 2026-11-18 14:56 ` sashiko-bot
0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-18 14:56 UTC (permalink / raw)
Cc: linux-security-module
> With vm.overcommit_memory=2, __vm_enough_memory() keeps the admin
> reserve for callers with CAP_SYS_ADMIN, which cap_vm_enough_memory()
> checks with cap_capable(), so a domain denying CAP_SYS_ADMIN cannot
> withhold this reserve, meant for an administrator to recover from memory
> exhaustion.
>
> Add a Landlock vm_enough_memory hook that withholds the reserve when the
> domain denies CAP_SYS_ADMIN. Like commoncap and SELinux, do not audit
> this check: it runs for every accounted mapping and only selects a
> limit.
>
> 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>
> Reviewed-by: Günther Noack <gnoack@google.com>
> Fixes: 97c8386f1d74 ("landlock: Enforce capability restrictions")
> Signed-off-by: Mickaël Salaün <mic@digikod.net>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261118145217.2551053-1-mic@digikod.net?part=4
^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH v3 2/6] landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr
2026-11-18 14:52 ` [PATCH v3 2/6] landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr Mickaël Salaün
@ 2026-11-18 14:57 ` sashiko-bot
0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-18 14:57 UTC (permalink / raw)
Cc: linux-security-module
> commoncap's mmap_addr hook checks CAP_SYS_RAWIO for mappings below
> vm.mmap_min_addr with cap_capable(), which skips the capable hook, so a
> domain denying CAP_SYS_RAWIO cannot prevent these mappings. Mapping the
> lowest pages helps to exploit kernel NULL pointer dereferences.
>
> Add a Landlock mmap_addr hook that checks CAP_SYS_RAWIO against the
> domain under the same condition, as SELinux checks its own mmap_zero
> permission in this hook. commoncap runs first, so the hook only sees
> mappings that commoncap allowed. This also covers the x86 vm86(2) and
> vm86old(2) system calls. Calling capable() from cap_mmap_addr() would
> instead expose this check to the capable hook of all LSMs.
>
> 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>
> Reviewed-by: Günther Noack <gnoack@google.com>
> Fixes: 97c8386f1d74 ("landlock: Enforce capability restrictions")
> Signed-off-by: Mickaël Salaün <mic@digikod.net>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261118145217.2551053-1-mic@digikod.net?part=2
^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH v3 3/6] landlock: Mediate CAP_SETPCAP for inheritable capabilities
2026-11-18 14:52 ` [PATCH v3 3/6] landlock: Mediate CAP_SETPCAP for inheritable capabilities Mickaël Salaün
@ 2026-11-18 14:58 ` sashiko-bot
0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-18 14:58 UTC (permalink / raw)
Cc: linux-security-module
> cap_capset() checks CAP_SETPCAP with cap_capable() (through
> cap_inh_is_capped()), which skips the capable hook, so a domain denying
> CAP_SETPCAP cannot prevent adding capabilities outside of the old
> inheritable and permitted sets to the inheritable set. Without
> no_new_privs (possible when a task with CAP_SYS_ADMIN enforced the
> domain), file inheritable capabilities can then grant permitted
> capabilities on execve().
>
> Add a Landlock capset hook that checks CAP_SETPCAP against the domain
> under the same condition, as SELinux checks its own setcap permission in
> this hook.
>
> 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>
> Reviewed-by: Günther Noack <gnoack@google.com>
> Fixes: 97c8386f1d74 ("landlock: Enforce capability restrictions")
> Signed-off-by: Mickaël Salaün <mic@digikod.net>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261118145217.2551053-1-mic@digikod.net?part=3
^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH v3 5/6] selftests/landlock: Test capability checks outside the capable hook
2026-11-18 14:52 ` [PATCH v3 5/6] selftests/landlock: Test capability checks outside the capable hook Mickaël Salaün
@ 2026-11-18 14:58 ` sashiko-bot
0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-18 14:58 UTC (permalink / raw)
Cc: linux-security-module
> Test the commoncap checks that the previous commits make Landlock
> restrict: mapping below vm.mmap_min_addr (CAP_SYS_RAWIO) and adding
> inheritable capabilities (CAP_SETPCAP). Each test checks that the
> operation needs the capability, then runs it with the capability in four
> variants: unsandboxed, denied, allowed and unhandled. The mmap_addr
> tests skip if the architecture rejects the low page before the hook
> (e.g. 32-bit ARM).
>
> Audit tests check that these denials are logged, and that the admin
> reserve check and allowed uses are not. The admin reserve has no
> functional test because it depends on vm.overcommit_memory=2, a
> system-wide setting.
>
> Add CAP_SETPCAP and CAP_SYS_RAWIO to the capabilities that the tests may
> raise.
>
> 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>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261118145217.2551053-1-mic@digikod.net?part=5
^ permalink raw reply [flat|nested] 13+ messages in thread
end of thread, other threads:[~2026-11-18 14:58 UTC | newest]
Thread overview: 13+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-18 14:52 [PATCH v3 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
2026-11-18 14:52 ` [PATCH v3 1/6] landlock: Factor out capability denial checks Mickaël Salaün
2026-11-18 14:55 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 2/6] landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr Mickaël Salaün
2026-11-18 14:57 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 3/6] landlock: Mediate CAP_SETPCAP for inheritable capabilities Mickaël Salaün
2026-11-18 14:58 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 4/6] landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve Mickaël Salaün
2026-11-18 14:56 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 5/6] selftests/landlock: Test capability checks outside the capable hook Mickaël Salaün
2026-11-18 14:58 ` sashiko-bot
2026-11-18 14:52 ` [PATCH v3 6/6] landlock: Fix capability restriction documentation Mickaël Salaün
2026-11-18 14:55 ` sashiko-bot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox