Landlock: file linking and renaming support
Subsystems (7)
Mickaël Salaün
maintainerv3 cover Landlock: file linking and renaming support
Hi,
This third patch series is mostly a rebase with some whitespace changes because of clang-format. There is also some new "unlikely()" calls and minor code cleanup.
Test coverage for security/landlock was 94.4% of 504 lines (with the previous patch series), and it is now 95.4% of 604 lines according to gcc/gcov-11.
Problem
=======
One of the most annoying limitations of Landlock is that sandboxed processes can only link and rename files to the same directory (i.e. file reparenting is always denied). Indeed, because of the unprivileged nature of Landlock, file hierarchy are identified thanks to ephemeral inode tagging, which may cause arbitrary renaming and linking to change the security policy in an unexpected way.
Solution
========
This patch series brings a new access right, LANDLOCK_ACCESS_FS_REFER, which enables to allow safe file linking and renaming. In a nutshell, Landlock checks that the inherited access rights of a moved or renamed file cannot increase but only reduce. Eleven new test suits cover file renaming and linking, which improves test coverage.
The documentation and the tutorial is extended with this new access right, along with more explanations about backward and forward compatibility, good practices, and a bit about the current access rights rational.
While developing this new feature, I also found an issue with the current implementation of Landlock. In some (rare) cases, sandboxed processes may be more restricted than intended. Indeed, because of the current way to check file hierarchy access rights, composition of rules may be incomplete when requesting multiple accesses at the same time. This is fixed with a dedicated patch involving some refactoring. A new test suite checks relevant new edge cases.
As a side effect, and to limit the increased use of the stack, I reduced the number of Landlock nested domains from 64 to 16. I think this should be more than enough for legitimate use cases, but feel free to challenge this decision with real and legitimate use cases.
Additionally, a new dedicated syzkaller test has been developed to cover new paths.
This patch series is based on and was developed with some complementary new tests sent in a standalone patch series:
https://lore.kernel.org/r/[email protected]
Previous versions:
v2: https://lore.kernel.org/r/[email protected]
v1: https://lore.kernel.org/r/[email protected]
Regards,
Mickaël Salaün (12):
landlock: Define access_mask_t to enforce a consistent access mask
size
landlock: Reduce the maximum number of layers to 16
landlock: Create find_rule() from unmask_layers()
landlock: Fix same-layer rule unions
landlock: Move filesystem helpers and add a new one
LSM: Remove double path_rename hook calls for RENAME_EXCHANGE
landlock: Add support for file reparenting with
LANDLOCK_ACCESS_FS_REFER
selftests/landlock: Add 11 new test suites dedicated to file
reparenting
samples/landlock: Add support for file reparenting
landlock: Document LANDLOCK_ACCESS_FS_REFER and ABI versioning
landlock: Document good practices about filesystem policies
landlock: Add design choices documentation for filesystem access
rights
Documentation/security/landlock.rst | 17 +- Documentation/userspace-api/landlock.rst | 151 ++- include/linux/lsm_hook_defs.h | 2 +- include/linux/lsm_hooks.h | 1 + include/uapi/linux/landlock.h | 27 +- samples/landlock/sandboxer.c | 40 +- security/apparmor/lsm.c | 30 +- security/landlock/fs.c | 771 ++++++++++--- security/landlock/fs.h | 2 +- security/landlock/limits.h | 6 +- security/landlock/ruleset.c | 6 +- security/landlock/ruleset.h | 22 +- security/landlock/syscalls.c | 2 +- security/security.c | 9 +- security/tomoyo/tomoyo.c | 11 +- tools/testing/selftests/landlock/base_test.c | 2 +- tools/testing/selftests/landlock/fs_test.c | 1039 ++++++++++++++++-- 17 files changed, 1853 insertions(+), 285 deletions(-)
base-commit: 4b0cdb0cf6eefa7521322007931ccfb7edc96c53
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 1/12 landlock: Define access_mask_t to enforce a consistent access mask size
Create and use the access_mask_t typedef to enforce a consistent access mask size and uniformly use a 16-bits type. This will helps transition to a 32-bits value one day.
Add a build check to make sure all (filesystem) access rights fit in. This will be extended with a following commit.
---
Changes since v2:
* Format with clang-format and rebase.
Changes since v1:
* Add Reviewed-by: Paul Moore.
--- security/landlock/fs.c | 19 +++++++++++-------- security/landlock/fs.h | 2 +- security/landlock/limits.h | 2 ++ security/landlock/ruleset.c | 6 ++++-- security/landlock/ruleset.h | 16 ++++++++++++---- 5 files changed, 30 insertions(+), 15 deletions(-)
security/landlock/fs.c +11 -8
@@ -152,7 +152,8 @@ static struct landlock_object *get_inode_object(struct inode *const inode)* @path: Should have been checked by get_path_from_fd(). */ int landlock_append_fs_rule (struct landlock_ruleset *const ruleset, -const struct path *const path,u32 access_rights) +const struct path *const path, +access_mask_t access_rights) {int err;struct landlock_object *object;
@@ -184,7 +185,8 @@ int landlock_append_fs_rule(struct landlock_ruleset *const ruleset,static inline u64 unmask_layers (const struct landlock_ruleset *const domain,const struct path *const path, -const u32 access_request,u64 layer_mask) +const access_mask_t access_request, +u64 layer_mask) {const struct landlock_rule *rule;const struct inode *inode;
@@ -224,7 +226,8 @@ static inline u64 unmask_layers(const struct landlock_ruleset *const domain, }static int check_access_path (const struct landlock_ruleset *const domain, -const struct path *const path,u32 access_request) +const struct path *const path, +const access_mask_t access_request) {bool allowed = false;struct path walker_path;
@@ -309,7 +312,7 @@ static int check_access_path(const struct landlock_ruleset *const domain, }static inline int current_check_access_path (const struct path *const path, -const u32 access_request) +const access_mask_t access_request) {const struct landlock_ruleset *const dom =landlock_get_current_domain ();
@@ -512,7 +515,7 @@ static int hook_sb_pivotroot(const struct path *const old_path,/* Path hooks */ -static inline u32 get_mode_access (const umode_t mode) +static inline access_mask_t get_mode_access (const umode_t mode) {switch (mode &S_IFMT ) {case S_IFLNK :
@@ -565,7 +568,7 @@ static int hook_path_link(struct dentry *const old_dentry, get_mode_access(d_backing_inode(old_dentry)->i_mode)); } -static inline u32 maybe_remove (const struct dentry *const dentry) +static inline access_mask_t maybe_remove (const struct dentry *const dentry) {if (d_is_negative (dentry))return 0 ;
@@ -635,9 +638,9 @@ static int hook_path_rmdir(const struct path *const dir,/* File hooks */ -static inline u32 get_file_access (const struct file *const file) +static inline access_mask_t get_file_access (const struct file *const file) { -u32 access =0 ; +access_mask_t access =0 ;if (file->f_mode &FMODE_READ ) {/* A directory can only be opened in read mode. */
security/landlock/fs.h +1 -1
@@ -66,6 +66,6 @@ __init void landlock_add_fs_hooks(void);int landlock_append_fs_rule (struct landlock_ruleset *const ruleset,const struct path *const path, -u32 access_hierarchy); +access_mask_t access_hierarchy);#endif /* _SECURITY_LANDLOCK_FS_H */
security/landlock/limits.h +2 -0
@@ -9,6 +9,7 @@#ifndef _SECURITY_LANDLOCK_LIMITS_H#define _SECURITY_LANDLOCK_LIMITS_H +#include <linux/bitops.h> #include <linux/limits.h> #include <uapi/linux/landlock.h>
@@ -19,6 +20,7 @@#define LANDLOCK_LAST_ACCESS_FS LANDLOCK_ACCESS_FS_MAKE_SYM#define LANDLOCK_MASK_ACCESS_FS ((LANDLOCK_LAST_ACCESS_FS << 1) - 1) +#define LANDLOCK_NUM_ACCESS_FS __const_hweight64(LANDLOCK_MASK_ACCESS_FS)/* clang-format on */
security/landlock/ruleset.c +4 -2
@@ -45,7 +45,8 @@ static struct landlock_ruleset *create_ruleset(const u32 num_layers)return new_ruleset; } -struct landlock_ruleset *landlock_create_ruleset (const u32 fs_access_mask) +struct landlock_ruleset * +landlock_create_ruleset (const access_mask_t fs_access_mask) {struct landlock_ruleset *new_ruleset;
@@ -228,7 +229,8 @@ static void build_check_layer(void)/* @ruleset must be locked by the caller. */ int landlock_insert_rule (struct landlock_ruleset *const ruleset, -struct landlock_object *const object,const u32 access) +struct landlock_object *const object, +const access_mask_t access) {struct landlock_layer layers[] = { { .access = access,
security/landlock/ruleset.h +12 -4
@@ -9,13 +9,20 @@#ifndef _SECURITY_LANDLOCK_RULESET_H#define _SECURITY_LANDLOCK_RULESET_H +#include <linux/bitops.h> +#include <linux/build_bug.h> #include <linux/mutex.h> #include <linux/rbtree.h> #include <linux/refcount.h> #include <linux/workqueue.h> +#include "limits.h" #include "object.h" +typedef u16 access_mask_t ; +/* Makes sure all filesystem access rights can be stored. */ +static_assert (BITS_PER_TYPE (access_mask_t) >=LANDLOCK_NUM_ACCESS_FS ); +/** * struct landlock_layer - Access rights for a given layer */
@@ -28,7 +35,7 @@ struct landlock_layer {* @access: Bitfield of allowed actions on the kernel object. They are * relative to the object type (e.g. %LANDLOCK_ACTION_FS_READ). */ -u16 access; +access_mask_t access; };/**
@@ -135,19 +142,20 @@ struct landlock_ruleset {* layers are set once and never changed for the * lifetime of the ruleset. */ -u16 fs_access_masks[]; +access_mask_t fs_access_masks[]; }; }; }; -struct landlock_ruleset *landlock_create_ruleset (const u32 fs_access_mask); +struct landlock_ruleset * +landlock_create_ruleset (const access_mask_t fs_access_mask);void landlock_put_ruleset (struct landlock_ruleset *const ruleset);void landlock_put_ruleset_deferred (struct landlock_ruleset *const ruleset);int landlock_insert_rule (struct landlock_ruleset *const ruleset,struct landlock_object *const object, -const u32 access); +const access_mask_t access);struct landlock_ruleset * landlock_merge_ruleset(struct landlock_ruleset *const parent,
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 2/12 landlock: Reduce the maximum number of layers to 16
In reply to Mickaël SalaünThe maximum number of nested Landlock domains is currently 64. Because of the following fix and to help reduce the stack size, let's reduce it to 16. This seems large enough for a lot of use cases (e.g. sandboxed init service, spawning a sandboxed SSH service, in nested sandboxed containers). Reducing the number of nested domains may also help to discover misuse of Landlock (e.g. creating a domain per rule).
Add and use a dedicated layer_mask_t typedef to fit with the number of layers. This might be useful when changing it and to keep it consistent with the maximum number of layers.
---
Changes since v2:
* Format with clang-format and rebase.
Changes since v1:
* Add Reviewed-by: Paul Moore.
* Update documentation to reflect this change.
--- Documentation/userspace-api/landlock.rst | 4 ++-- security/landlock/fs.c | 17 +++++++---------- security/landlock/limits.h | 2 +- security/landlock/ruleset.h | 4 ++++ tools/testing/selftests/landlock/fs_test.c | 2 +- 5 files changed, 15 insertions(+), 14 deletions(-)
Documentation/userspace-api/landlock.rst +2 -2
@@ -267,8 +267,8 @@ restrict such paths with dedicated ruleset flags. Ruleset layers -------------- -There is a limit of 64 layers of stacked rulesets. This can be an issue for a -task willing to enforce a new ruleset in complement to its 64 inherited +There is a limit of 16 layers of stacked rulesets. This can be an issue for a +task willing to enforce a new ruleset in complement to its 16 inherited rulesets. Once this limit is reached, sys_landlock_restrict_self() returns E2BIG. It is then strongly suggested to carefully build rulesets once in the life of a thread, especially for applications able to launch other applications
security/landlock/fs.c +7 -10
@@ -183,10 +183,10 @@ int landlock_append_fs_rule(struct landlock_ruleset *const ruleset,/* Access-control management */ -static inline u64 unmask_layers (const struct landlock_ruleset *const domain, -const struct path *const path, -const access_mask_t access_request, -u64 layer_mask) +static inline layer_mask_t +unmask_layers (const struct landlock_ruleset *const domain, +const struct path *const path,const access_mask_t access_request, +layer_mask_t layer_mask) {const struct landlock_rule *rule;const struct inode *inode;
@@ -212,11 +212,11 @@ static inline u64 unmask_layers(const struct landlock_ruleset *const domain,*/ for (i =0 ; i < rule->num_layers; i++) {const struct landlock_layer *const layer = &rule->layers[i]; -const u64 layer_level =BIT_ULL (layer->level -1 ); +const layer_mask_t layer_bit =BIT_ULL (layer->level -1 );/* Checks that the layer grants access to the full request. */ if ((layer->access & access_request) == access_request) { - layer_mask &= ~layer_level; + layer_mask &= ~layer_bit;if (layer_mask ==0 )return layer_mask;
@@ -231,12 +231,9 @@ static int check_access_path(const struct landlock_ruleset *const domain, {bool allowed = false;struct path walker_path; -u64 layer_mask; +layer_mask_t layer_mask;size_t i; -/* Make sure all layers can be checked. */ -BUILD_BUG_ON (BITS_PER_TYPE (layer_mask) <LANDLOCK_MAX_NUM_LAYERS ); -if (!access_request)return 0 ;if (WARN_ON_ONCE (!domain || !path))
security/landlock/limits.h +1 -1
@@ -15,7 +15,7 @@/* clang-format off */ -#define LANDLOCK_MAX_NUM_LAYERS 64 +#define LANDLOCK_MAX_NUM_LAYERS 16#define LANDLOCK_MAX_NUM_RULES U32_MAX#define LANDLOCK_LAST_ACCESS_FS LANDLOCK_ACCESS_FS_MAKE_SYM
security/landlock/ruleset.h +4 -0
@@ -23,6 +23,10 @@ typedef u16 access_mask_t;/* Makes sure all filesystem access rights can be stored. */ static_assert (BITS_PER_TYPE (access_mask_t) >=LANDLOCK_NUM_ACCESS_FS ); +typedef u16 layer_mask_t ; +/* Makes sure all layers can be checked. */ +static_assert (BITS_PER_TYPE (layer_mask_t) >=LANDLOCK_MAX_NUM_LAYERS ); +/** * struct landlock_layer - Access rights for a given layer */
tools/testing/selftests/landlock/fs_test.c +1 -1
@@ -1159,7 +1159,7 @@ TEST_F_FORK(layout1, max_layers)const int ruleset_fd =create_ruleset (_metadata,ACCESS_RW , rules);ASSERT_LE (0 , ruleset_fd); -for (i =0 ; i <64 ; i++) +for (i =0 ; i <16 ; i++)enforce_ruleset (_metadata, ruleset_fd);for (i =0 ; i <2 ; i++) {
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 3/12 landlock: Create find_rule() from unmask_layers()
In reply to Mickaël SalaünThis refactoring will be useful in a following commit.
---
Changes since v2:
* Format with clang-format and rebase.
Changes since v1:
* Add Reviewed-by: Paul Moore.
--- security/landlock/fs.c | 41 ++++++++++++++++++++++++++++------------- 1 file changed, 28 insertions(+), 13 deletions(-)
security/landlock/fs.c +28 -13
@@ -183,23 +183,36 @@ int landlock_append_fs_rule(struct landlock_ruleset *const ruleset,/* Access-control management */ -static inline layer_mask_t -unmask_layers (const struct landlock_ruleset *const domain, -const struct path *const path,const access_mask_t access_request, -layer_mask_t layer_mask) +/* +* The lifetime of the returned rule is tied to @domain. +* +* Returns NULL if no rule is found or if @dentry is negative. +*/ +static inline const struct landlock_rule * +find_rule (const struct landlock_ruleset *const domain, +const struct dentry *const dentry) {const struct landlock_rule *rule;const struct inode *inode; -size_t i; -if (d_is_negative (path->dentry)) -/* Ignore nonexistent leafs. */ -return layer_mask; - inode =d_backing_inode (path->dentry); +/* Ignores nonexistent leafs. */ +if (d_is_negative (dentry)) +return NULL ; + + inode =d_backing_inode (dentry);rcu_read_lock (); rule =landlock_find_rule ( domain,rcu_dereference (landlock_inode (inode)->object));rcu_read_unlock (); +return rule; +} + +static inline layer_mask_t unmask_layers (const struct landlock_rule *const rule, +const access_mask_t access_request, +layer_mask_t layer_mask) +{ +size_t layer_level; +if (!rule)return layer_mask;
@@ -210,8 +223,9 @@ unmask_layers(const struct landlock_ruleset *const domain,* the remaining layers for each inode, from the first added layer to * the last one. */ -for (i =0 ; i < rule->num_layers; i++) { -const struct landlock_layer *const layer = &rule->layers[i]; +for (layer_level =0 ; layer_level < rule->num_layers; layer_level++) { +const struct landlock_layer *const layer = + &rule->layers[layer_level];const layer_mask_t layer_bit =BIT_ULL (layer->level -1 );/* Checks that the layer grants access to the full request. */
@@ -269,8 +283,9 @@ static int check_access_path(const struct landlock_ruleset *const domain,while (true) {struct dentry *parent_dentry; - layer_mask =unmask_layers (domain, &walker_path, access_request, - layer_mask); + layer_mask = +unmask_layers (find_rule (domain, walker_path.dentry), + access_request, layer_mask);if (layer_mask ==0 ) {/* Stops when a rule from each layer grants access. */ allowed = true;
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 4/12 landlock: Fix same-layer rule unions
In reply to Mickaël SalaünThe original behavior was to check if the full set of requested accesses was allowed by at least a rule of every relevant layer. This didn't take into account requests for multiple accesses and same-layer rules allowing the union of these accesses in a complementary way. As a result, multiple accesses requested on a file hierarchy matching rules that, together, allowed these accesses, but without a unique rule allowing all of them, was illegitimately denied. This case should be rare in practice and it can only be triggered by the path_rename or file_open hook implementations.
For instance, if, for the same layer, a rule allows execution beneath /a/b and another rule allows read beneath /a, requesting access to read and execute at the same time for /a/b should be allowed for this layer.
This was an inconsistency because the union of same-layer rule accesses was already allowed if requested once at a time anyway.
This fix changes the way allowed accesses are gathered over a path walk. To take into account all these rule accesses, we store in a matrix all layer granting the set of requested accesses, according to the handled accesses. To avoid heap allocation, we use an array on the stack which is 2*13 bytes. A following commit bringing the LANDLOCK_ACCESS_FS_REFER access right will increase this size to reach 112 bytes (2*14*4) in case of link or rename actions.
Add a new layout1.layer_rule_unions test to check that accesses from different rules pertaining to the same layer are ORed in a file hierarchy. Also test that it is not the case for rules from different layers.
---
Changes since v2:
* Fix commit message about stack size.
* Format with clang-format and rebase.
Changes since v1:
* Add Reviewed-by: Paul Moore.
* Small cosmetic comment cleanup.
--- security/landlock/fs.c | 78 ++++++++++----- security/landlock/ruleset.h | 2 + tools/testing/selftests/landlock/fs_test.c | 107 +++++++++++++++++++++ 3 files changed, 161 insertions(+), 26 deletions(-)
security/landlock/fs.c +52 -26
@@ -207,45 +207,67 @@ find_rule(const struct landlock_ruleset *const domain,return rule; } -static inline layer_mask_t unmask_layers (const struct landlock_rule *const rule, -const access_mask_t access_request, -layer_mask_t layer_mask) +/* +* @layer_masks is read and may be updated according to the access request and +* the matching rule. +* +* Returns true if the request is allowed (i.e. relevant layer masks for the +* request are empty). +*/ +static inline bool +unmask_layers (const struct landlock_rule *const rule, +const access_mask_t access_request, +layer_mask_t (*const layer_masks)[LANDLOCK_NUM_ACCESS_FS ]) {size_t layer_level; +if (!access_request || !layer_masks) +return true;if (!rule) -return layer_mask; +return false;/* * An access is granted if, for each policy layer, at least one rule -* encountered on the pathwalk grants the requested accesses, -* regardless of their position in the layer stack. We must then check +* encountered on the pathwalk grants the requested access, +* regardless of its position in the layer stack. We must then check * the remaining layers for each inode, from the first added layer to -* the last one. +* the last one. When there is multiple requested accesses, for each +* policy layer, the full set of requested accesses may not be granted +* by only one rule, but by the union (binary OR) of multiple rules. +* E.g. /a/b <execute> + /a <read> => /a/b <execute + read> */ for (layer_level =0 ; layer_level < rule->num_layers; layer_level++) {const struct landlock_layer *const layer = &rule->layers[layer_level];const layer_mask_t layer_bit =BIT_ULL (layer->level -1 ); +const unsigned long access_req = access_request; +unsigned long access_bit; +bool is_empty; -/* Checks that the layer grants access to the full request. */ -if ((layer->access & access_request) == access_request) { - layer_mask &= ~layer_bit; - -if (layer_mask ==0 ) -return layer_mask; +/* +* Records in @layer_masks which layer grants access to each +* requested access. +*/ + is_empty = true; +for_each_set_bit (access_bit, &access_req, +ARRAY_SIZE (*layer_masks)) { +if (layer->access &BIT_ULL (access_bit)) + (*layer_masks)[access_bit] &= ~layer_bit; + is_empty = is_empty && !(*layer_masks)[access_bit]; } +if (is_empty) +return true; } -return layer_mask; +return false; }static int check_access_path (const struct landlock_ruleset *const domain,const struct path *const path,const access_mask_t access_request) { -bool allowed = false; +layer_mask_t layer_masks[LANDLOCK_NUM_ACCESS_FS ] = {}; +bool allowed = false, has_access = false;struct path walker_path; -layer_mask_t layer_mask;size_t i;if (!access_request)
@@ -265,13 +287,20 @@ static int check_access_path(const struct landlock_ruleset *const domain,return -EACCES ;/* Saves all layers handling a subset of requested accesses. */ - layer_mask =0 ;for (i =0 ; i < domain->num_layers; i++) { -if (domain->fs_access_masks[i] & access_request) - layer_mask |=BIT_ULL (i); +const unsigned long access_req = access_request; +unsigned long access_bit; + +for_each_set_bit (access_bit, &access_req, +ARRAY_SIZE (layer_masks)) { +if (domain->fs_access_masks[i] &BIT_ULL (access_bit)) { + layer_masks[access_bit] |=BIT_ULL (i); + has_access = true; + } + } }/* An access request not handled by the domain is allowed. */ -if (layer_mask ==0 ) +if (!has_access)return 0 ; walker_path = *path;
@@ -283,14 +312,11 @@ static int check_access_path(const struct landlock_ruleset *const domain,while (true) {struct dentry *parent_dentry; - layer_mask = -unmask_layers (find_rule (domain, walker_path.dentry), - access_request, layer_mask); -if (layer_mask ==0 ) { + allowed =unmask_layers (find_rule (domain, walker_path.dentry), + access_request, &layer_masks); +if (allowed)/* Stops when a rule from each layer grants access. */ - allowed = true;break ; - } jump_up:if (walker_path.dentry == walker_path.mnt->mnt_root) {
security/landlock/ruleset.h +2 -0
@@ -22,6 +22,8 @@typedef u16 access_mask_t ;/* Makes sure all filesystem access rights can be stored. */ static_assert (BITS_PER_TYPE (access_mask_t) >=LANDLOCK_NUM_ACCESS_FS ); +/* Makes sure for_each_set_bit() and for_each_clear_bit() calls are OK. */ +static_assert (sizeof (unsigned long ) >=sizeof (access_mask_t));typedef u16 layer_mask_t ;/* Makes sure all layers can be checked. */
tools/testing/selftests/landlock/fs_test.c +107 -0
113 lines not on this page · raw message
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 5/12 landlock: Move filesystem helpers and add a new one
In reply to Mickaël SalaünMove the SB_NOUSER and IS_PRIVATE dentry check to a standalone is_nouser_or_private() helper. This will be useful for a following commit.
Move get_mode_access() and maybe_remove() to make them usable by new code provided by a following commit.
---
Changes since v2:
* Format with clang-format and rebase.
Changes since v1:
* Move is_nouser_or_private() explanation up to a function header comment block as suggested by Paul Moore.
* Add Reviewed-by: Paul Moore.
--- security/landlock/fs.c | 87 ++++++++++++++++++++++-------------------- 1 file changed, 46 insertions(+), 41 deletions(-)
security/landlock/fs.c +46 -41
@@ -261,6 +261,18 @@ unmask_layers(const struct landlock_rule *const rule,return false; } +/* +* Allows access to pseudo filesystems that will never be mountable (e.g. +* sockfs, pipefs), but can still be reachable through +* /proc/<pid>/fd/<file-descriptor> +*/ +static inline bool is_nouser_or_private (const struct dentry *dentry) +{ +return (dentry->d_sb->s_flags &SB_NOUSER ) || + (d_is_positive (dentry) && +unlikely (IS_PRIVATE (d_backing_inode (dentry)))); +} +static int check_access_path (const struct landlock_ruleset *const domain,const struct path *const path,const access_mask_t access_request)
@@ -274,14 +286,7 @@ static int check_access_path(const struct landlock_ruleset *const domain,return 0 ;if (WARN_ON_ONCE (!domain || !path))return 0 ; -/* -* Allows access to pseudo filesystems that will never be mountable -* (e.g. sockfs, pipefs), but can still be reachable through -* /proc/<pid>/fd/<file-descriptor> . -*/ -if ((path->dentry->d_sb->s_flags &SB_NOUSER ) || - (d_is_positive (path->dentry) && -unlikely (IS_PRIVATE (d_backing_inode (path->dentry))))) +if (is_nouser_or_private (path->dentry))return 0 ;if (WARN_ON_ONCE (domain->num_layers <1 ))return -EACCES ;
@@ -360,6 +365,39 @@ static inline int current_check_access_path(const struct path *const path,return check_access_path (dom, path, access_request); } +static inline access_mask_t get_mode_access (const umode_t mode) +{ +switch (mode &S_IFMT ) { +case S_IFLNK : +return LANDLOCK_ACCESS_FS_MAKE_SYM ; +case 0 : +/* A zero mode translates to S_IFREG. */ +case S_IFREG : +return LANDLOCK_ACCESS_FS_MAKE_REG ; +case S_IFDIR : +return LANDLOCK_ACCESS_FS_MAKE_DIR ; +case S_IFCHR : +return LANDLOCK_ACCESS_FS_MAKE_CHAR ; +case S_IFBLK : +return LANDLOCK_ACCESS_FS_MAKE_BLOCK ; +case S_IFIFO : +return LANDLOCK_ACCESS_FS_MAKE_FIFO ; +case S_IFSOCK : +return LANDLOCK_ACCESS_FS_MAKE_SOCK ; +default : +WARN_ON_ONCE (1 ); +return 0 ; + } +} + +static inline access_mask_t maybe_remove (const struct dentry *const dentry) +{ +if (d_is_negative (dentry)) +return 0 ; +return d_is_dir (dentry) ?LANDLOCK_ACCESS_FS_REMOVE_DIR : +LANDLOCK_ACCESS_FS_REMOVE_FILE ; +} +/* Inode hooks */ static void hook_inode_free_security (struct inode *const inode)
@@ -553,31 +591,6 @@ static int hook_sb_pivotroot(const struct path *const old_path,/* Path hooks */ -static inline access_mask_t get_mode_access (const umode_t mode) -{ -switch (mode &S_IFMT ) { -case S_IFLNK : -return LANDLOCK_ACCESS_FS_MAKE_SYM ; -case 0 : -/* A zero mode translates to S_IFREG. */ -case S_IFREG : -return LANDLOCK_ACCESS_FS_MAKE_REG ; -case S_IFDIR : -return LANDLOCK_ACCESS_FS_MAKE_DIR ; -case S_IFCHR : -return LANDLOCK_ACCESS_FS_MAKE_CHAR ; -case S_IFBLK : -return LANDLOCK_ACCESS_FS_MAKE_BLOCK ; -case S_IFIFO : -return LANDLOCK_ACCESS_FS_MAKE_FIFO ; -case S_IFSOCK : -return LANDLOCK_ACCESS_FS_MAKE_SOCK ; -default : -WARN_ON_ONCE (1 ); -return 0 ; - } -} -/* * Creating multiple links or renaming may lead to privilege escalations if not * handled properly. Indeed, we must be sure that the source doesn't gain more
@@ -606,14 +619,6 @@ static int hook_path_link(struct dentry *const old_dentry, get_mode_access(d_backing_inode(old_dentry)->i_mode)); } -static inline access_mask_t maybe_remove (const struct dentry *const dentry) -{ -if (d_is_negative (dentry)) -return 0 ; -return d_is_dir (dentry) ?LANDLOCK_ACCESS_FS_REMOVE_DIR : -LANDLOCK_ACCESS_FS_REMOVE_FILE ; -} - static int hook_path_rename(const struct path *const old_dir, struct dentry *const old_dentry, const struct path *const new_dir,
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 6/12 LSM: Remove double path_rename hook calls for RENAME_EXCHANGE
In reply to Mickaël SalaünIn order to be able to identify a file exchange with renameat2(2) and RENAME_EXCHANGE, which will be useful for Landlock [1], propagate the rename flags to LSMs. This may also improve performance because of the switch from two set of LSM hook calls to only one, and because LSMs using this hook may optimize the double check (e.g. only one lock, reduce the number of path walks).
AppArmor, Landlock and Tomoyo are updated to leverage this change. This should not change the current behavior (same check order), except (different level of) speed boosts.
[1] https://lore.kernel.org/r/[email protected]
---
Changes since v2:
* Add Reviewed-by: Paul Moore.
* Format security/landlock/fs.c with clang-format.
Changes since v1:
* Import patch from
https://lore.kernel.org/r/[email protected]
* Add Acked-by: Tetsuo Handa.
* Add Acked-by: John Johansen.
--- include/linux/lsm_hook_defs.h | 2 +- include/linux/lsm_hooks.h | 1 + security/apparmor/lsm.c | 30 +++++++++++++++++++++++++----- security/landlock/fs.c | 11 ++++++++++- security/security.c | 9 +-------- security/tomoyo/tomoyo.c | 11 ++++++++++- 6 files changed, 48 insertions(+), 16 deletions(-)
include/linux/lsm_hook_defs.h +1 -1
@@ -100,7 +100,7 @@ LSM_HOOK(int, 0, path_link, struct dentry *old_dentry, const struct path *new_dir, struct dentry *new_dentry) LSM_HOOK(int, 0, path_rename, const struct path *old_dir, struct dentry *old_dentry, const struct path *new_dir, - struct dentry *new_dentry) + struct dentry *new_dentry, unsigned int flags) LSM_HOOK(int, 0, path_chmod, const struct path *path, umode_t mode) LSM_HOOK(int, 0, path_chown, const struct path *path, kuid_t uid, kgid_t gid) LSM_HOOK(int, 0, path_chroot, const struct path *path)
include/linux/lsm_hooks.h +1 -0
@@ -358,6 +358,7 @@* @old_dentry contains the dentry structure of the old link. * @new_dir contains the path structure for parent of the new link. * @new_dentry contains the dentry structure of the new link. +* @flags may contain rename options such as RENAME_EXCHANGE. * Return 0 if permission is granted. * @path_chmod: * Check for permission to change a mode of the file @path. The new
security/apparmor/lsm.c +25 -5
@@ -354,13 +354,16 @@ static int apparmor_path_link(struct dentry *old_dentry, const struct path *new_ }static int apparmor_path_rename (const struct path *old_dir,struct dentry *old_dentry, -const struct path *new_dir,struct dentry *new_dentry) +const struct path *new_dir,struct dentry *new_dentry, +const unsigned int flags) {struct aa_label *label;int error =0 ;if (!path_mediated_fs (old_dentry))return 0 ; +if ((flags &RENAME_EXCHANGE ) && !path_mediated_fs (new_dentry)) +return 0 ; label =begin_current_label_crit_section ();if (!unconfined (label)) {
@@ -374,10 +377,27 @@ static int apparmor_path_rename(const struct path *old_dir, struct dentry *old_dd_backing_inode (old_dentry)->i_mode }; - error =aa_path_perm (OP_RENAME_SRC , label, &old_path,0 , -MAY_READ |AA_MAY_GETATTR |MAY_WRITE | -AA_MAY_SETATTR |AA_MAY_DELETE , - &cond); +if (flags &RENAME_EXCHANGE ) { +struct path_cond cond_exchange = { +i_uid_into_mnt (mnt_userns,d_backing_inode (new_dentry)), +d_backing_inode (new_dentry)->i_mode + }; + + error =aa_path_perm (OP_RENAME_SRC , label, &new_path,0 , +MAY_READ |AA_MAY_GETATTR |MAY_WRITE | +AA_MAY_SETATTR |AA_MAY_DELETE , + &cond_exchange); +if (!error) + error =aa_path_perm (OP_RENAME_DEST , label, &old_path, +0 ,MAY_WRITE |AA_MAY_SETATTR | +AA_MAY_CREATE , &cond_exchange); + } + +if (!error) + error =aa_path_perm (OP_RENAME_SRC , label, &old_path,0 , +MAY_READ |AA_MAY_GETATTR |MAY_WRITE | +AA_MAY_SETATTR |AA_MAY_DELETE , + &cond);if (!error) error = aa_path_perm(OP_RENAME_DEST, label, &new_path, 0, MAY_WRITE | AA_MAY_SETATTR |
security/landlock/fs.c +10 -1
@@ -622,10 +622,12 @@ static int hook_path_link(struct dentry *const old_dentry,static int hook_path_rename (const struct path *const old_dir,struct dentry *const old_dentry,const struct path *const new_dir, -struct dentry *const new_dentry) +struct dentry *const new_dentry, +const unsigned int flags) {const struct landlock_ruleset *const dom =landlock_get_current_domain (); +u32 exchange_access =0 ;if (!dom)return 0 ;
@@ -633,12 +635,19 @@ static int hook_path_rename(const struct path *const old_dir,if (old_dir->dentry != new_dir->dentry)/* Gracefully forbids reparenting. */ return -EXDEV ; +if (flags &RENAME_EXCHANGE ) { +if (unlikely (d_is_negative (new_dentry))) +return -ENOENT ; + exchange_access = +get_mode_access (d_backing_inode (new_dentry)->i_mode); + }if (unlikely (d_is_negative (old_dentry)))return -ENOENT ;/* RENAME_EXCHANGE is handled because directories are the same. */ return check_access_path ( dom, old_dir,maybe_remove (old_dentry) |maybe_remove (new_dentry) | + exchange_access |get_mode_access (d_backing_inode (old_dentry)->i_mode)); }
security/security.c +1 -8
@@ -1197,15 +1197,8 @@ int security_path_rename(const struct path *old_dir, struct dentry *old_dentry, (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry)))))return 0 ; -if (flags &RENAME_EXCHANGE ) { -int err =call_int_hook (path_rename,0 , new_dir, new_dentry, - old_dir, old_dentry); -if (err) -return err; - } -return call_int_hook (path_rename,0 , old_dir, old_dentry, new_dir, - new_dentry); + new_dentry, flags); }EXPORT_SYMBOL (security_path_rename);
security/tomoyo/tomoyo.c +10 -1
@@ -264,17 +264,26 @@ static int tomoyo_path_link(struct dentry *old_dentry, const struct path *new_di* @old_dentry: Pointer to "struct dentry". * @new_parent: Pointer to "struct path". * @new_dentry: Pointer to "struct dentry". +* @flags: Rename options. * * Returns 0 on success, negative value otherwise. */ static int tomoyo_path_rename (const struct path *old_parent,struct dentry *old_dentry,const struct path *new_parent, -struct dentry *new_dentry) +struct dentry *new_dentry, +const unsigned int flags) {struct path path1 = { .mnt = old_parent->mnt, .dentry = old_dentry };struct path path2 = { .mnt = new_parent->mnt, .dentry = new_dentry }; +if (flags &RENAME_EXCHANGE ) { +const int err =tomoyo_path2_perm (TOMOYO_TYPE_RENAME , &path2, + &path1); + +if (err) +return err; + }return tomoyo_path2_perm (TOMOYO_TYPE_RENAME , &path1, &path2); }
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 7/12 landlock: Add support for file reparenting with LANDLOCK_ACCESS_FS_REFER
In reply to Mickaël SalaünAdd a new LANDLOCK_ACCESS_FS_REFER access right to enable policy writers to allow sandboxed processes to link and rename files from and to a specific set of file hierarchies. This access right should be composed with LANDLOCK_ACCESS_FS_MAKE_* for the destination of a link or rename, and with LANDLOCK_ACCESS_FS_REMOVE_* for a source of a rename. This lift a Landlock limitation that always denied changing the parent of an inode.
Renaming or linking to the same directory is still always allowed, whatever LANDLOCK_ACCESS_FS_REFER is used or not, because it is not considered a threat to user data.
However, creating multiple links or renaming to a different parent directory may lead to privilege escalations if not handled properly. Indeed, we must be sure that the source doesn't gain more privileges by being accessible from the destination. This is handled by making sure that the source hierarchy (including the referenced file or directory itself) restricts at least as much the destination hierarchy. If it is not the case, an EXDEV error is returned, making it potentially possible for user space to copy the file hierarchy instead of moving or linking it.
Instead of creating different access rights for the source and the destination, we choose to make it simple and consistent for users. Indeed, considering the previous constraint, it would be weird to require such destination access right to be also granted to the source (to make it a superset). Moreover, RENAME_EXCHANGE would also add to the confusion because of paths being both a source and a destination.
See the provided documentation for additional details.
New tests are provided with a following commit.
---
Changes since v2:
* Add Reviewed-by: Paul Moore.
* Update collect_domain_accesses() documentation for the RENAME_EXCHANGE case and fix spelling.
* Add unlikely() branches in check_access_path_dual() to favor single access request (i.e. non-refer actions).
* Remove useless ret assignment in collect_domain_accesses().
* Format with clang-format and rebase.
Changes since v1:
* Update current_check_access_path() to efficiently handle RENAME_EXCHANGE thanks to the updated LSM hook (see previous patch). Only one path walk is performed per rename arguments until their common mount point is reached. Superset of access rights is correctly checked, including when exchanging a file with a directory. This requires to store another matrix of layer masks.
* Reorder and rename check_access_path_dual() arguments in a more generic way: switch from src/dst to 1/2. This makes it easier to understand the RENAME_EXCHANGE cases alongs with the others. Update and improve check_access_path_dual() documentation accordingly.
* Clean up the check_access_path_dual() loop: set both allowed_parent* when reaching internal filesystems and remove a useless one. This allows potential renames in internal filesystems (like for other operations).
* Move the function arguments checks from BUILD_BUG_ON() to WARN_ON_ONCE() to avoid clang build error.
* Rename is_superset() to no_more_access() and make it handle superset checks of source and destination for simple and exchange cases.
* Move the layer_masks_child* creation from current_check_refer_path() to check_access_path_dual(): this is simpler and less error-prone, especially with RENAME_EXCHANGE.
* Remove one optimization in current_check_refer_path() to make the code simpler, especially with the RENAME_EXCHANGE handling.
* Remove overzealous WARN_ON_ONCE() for !access_request check in init_layer_masks().
--- include/uapi/linux/landlock.h | 27 +- security/landlock/fs.c | 600 ++++++++++++++++--- security/landlock/limits.h | 2 +- security/landlock/syscalls.c | 2 +- tools/testing/selftests/landlock/base_test.c | 2 +- tools/testing/selftests/landlock/fs_test.c | 3 +- 6 files changed, 556 insertions(+), 80 deletions(-)
include/uapi/linux/landlock.h +25 -2
@@ -21,8 +21,14 @@ struct landlock_ruleset_attr {/** * @handled_access_fs: Bitmask of actions (cf. `Filesystem flags`_) * that is handled by this ruleset and should then be forbidden if no -* rule explicitly allow them. This is needed for backward -* compatibility reasons. +* rule explicitly allow them: it is a deny-by-default list that should +* contain as much Landlock access rights as possible. Indeed, all +* Landlock filesystem access rights that are not part of +* handled_access_fs are allowed. This is needed for backward +* compatibility reasons. One exception is the +* LANDLOCK_ACCESS_FS_REFER access right, which is always implicitly +* handled, but must still be explicitly handled to add new rules with +* this access right. */ __u64 handled_access_fs; };
@@ -112,6 +118,22 @@ struct landlock_path_beneath_attr {* - %LANDLOCK_ACCESS_FS_MAKE_FIFO: Create (or rename or link) a named pipe. * - %LANDLOCK_ACCESS_FS_MAKE_BLOCK: Create (or rename or link) a block device. * - %LANDLOCK_ACCESS_FS_MAKE_SYM: Create (or rename or link) a symbolic link. +* - %LANDLOCK_ACCESS_FS_REFER: Link or rename a file from or to a different +* directory (i.e. reparent a file hierarchy). This access right is +* available since the second version of the Landlock ABI. This is also the +* only access right which is always considered handled by any ruleset in +* such a way that reparenting a file hierarchy is always denied by default. +* To avoid privilege escalation, it is not enough to add a rule with this +* access right. When linking or renaming a file, the destination directory +* hierarchy must also always have the same or a superset of restrictions of +* the source hierarchy. If it is not the case, or if the domain doesn't +* handle this access right, such actions are denied by default with errno +* set to EXDEV. Linking also requires a LANDLOCK_ACCESS_FS_MAKE_* access +* right on the destination directory, and renaming also requires a +* LANDLOCK_ACCESS_FS_REMOVE_* access right on the source's (file or +* directory) parent. Otherwise, such actions are denied with errno set to +* EACCES. The EACCES errno prevails over EXDEV to let user space +* efficiently deal with an unrecoverable error. * * .. warning:: *
@@ -137,6 +159,7 @@ struct landlock_path_beneath_attr {#define LANDLOCK_ACCESS_FS_MAKE_FIFO (1ULL << 10)#define LANDLOCK_ACCESS_FS_MAKE_BLOCK (1ULL << 11)#define LANDLOCK_ACCESS_FS_MAKE_SYM (1ULL << 12) +#define LANDLOCK_ACCESS_FS_REFER (1ULL << 13)/* clang-format on */ #endif /* _UAPI_LINUX_LANDLOCK_H */
security/landlock/fs.c +526 -74
672 lines not on this page · raw message
security/landlock/limits.h +1 -1
@@ -18,7 +18,7 @@#define LANDLOCK_MAX_NUM_LAYERS 16#define LANDLOCK_MAX_NUM_RULES U32_MAX -#define LANDLOCK_LAST_ACCESS_FS LANDLOCK_ACCESS_FS_MAKE_SYM +#define LANDLOCK_LAST_ACCESS_FS LANDLOCK_ACCESS_FS_REFER#define LANDLOCK_MASK_ACCESS_FS ((LANDLOCK_LAST_ACCESS_FS << 1) - 1)#define LANDLOCK_NUM_ACCESS_FS __const_hweight64(LANDLOCK_MASK_ACCESS_FS)
security/landlock/syscalls.c +1 -1
@@ -129,7 +129,7 @@ static const struct file_operations ruleset_fops = { .write = fop_dummy_write, }; -#define LANDLOCK_ABI_VERSION 1 +#define LANDLOCK_ABI_VERSION 2/** * sys_landlock_create_ruleset - Create a new ruleset
tools/testing/selftests/landlock/base_test.c +1 -1
@@ -75,7 +75,7 @@ TEST(abi_version)const struct landlock_ruleset_attr ruleset_attr = { .handled_access_fs =LANDLOCK_ACCESS_FS_READ_FILE , }; -ASSERT_EQ (1 ,landlock_create_ruleset (NULL ,0 , +ASSERT_EQ (2 ,landlock_create_ruleset (NULL ,0 ,LANDLOCK_CREATE_RULESET_VERSION )); ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 0,
tools/testing/selftests/landlock/fs_test.c +2 -1
@@ -401,7 +401,7 @@ TEST_F_FORK(layout1, inval) LANDLOCK_ACCESS_FS_WRITE_FILE | \ LANDLOCK_ACCESS_FS_READ_FILE) -#define ACCESS_LAST LANDLOCK_ACCESS_FS_MAKE_SYM +#define ACCESS_LAST LANDLOCK_ACCESS_FS_REFER#define ACCESS_ALL ( \ ACCESS_FILE | \
@@ -414,6 +414,7 @@ TEST_F_FORK(layout1, inval)LANDLOCK_ACCESS_FS_MAKE_SOCK | \LANDLOCK_ACCESS_FS_MAKE_FIFO | \LANDLOCK_ACCESS_FS_MAKE_BLOCK | \ +LANDLOCK_ACCESS_FS_MAKE_SYM | \ ACCESS_LAST)/* clang-format on */
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 8/12 selftests/landlock: Add 11 new test suites dedicated to file reparenting
In reply to Mickaël SalaünThese test suites try to check all edge cases for directory and file renaming or linking involving a new parent directory, with and without LANDLOCK_ACCESS_FS_REFER and other access rights.
layout1:
* reparent_refer: Tests simple FS_REFER usage.
* reparent_link: Tests a mix of FS_MAKE_REG and FS_REFER with links.
* reparent_rename: Tests a mix of FS_MAKE_REG and FS_REFER with renames and RENAME_EXCHANGE.
* reparent_exdev_layers_rename1/2: Tests renames with two layers.
* reparent_exdev_layers_exchange1/2/3: Tests exchanges with two layers.
* reparent_remove: Tests file and directory removal with rename.
* reparent_dom_superset: Tests access partial ordering.
layout1_bind:
* reparent_cross_mount: Tests FS_REFER propagation across mount points.
Test coverage for security/landlock is 95.4% of 604 lines according to gcc/gcov-11.
---
Changes since v2:
* Add test coverage in patch description.
* Format with clang-format and rebase.
Changes since v1:
* Add tests specific to RENAME_EXCHANGE and split layout1.reparent_exdev_layers to avoid inconsistent layout modifications and make these tests easier to understand.
* Add full error predominance tests with RENAME_EXCHANGE to layout1.reparent_exdev_layers* . This now work as expected thanks to the rename hook change.
* Add layout1.reparent_remove tests to check file and directory removal with rename.
* Improve the remove_path() helper to handle unlinking paths with non-existing components.
--- tools/testing/selftests/landlock/fs_test.c | 755 ++++++++++++++++++++- 1 file changed, 754 insertions(+), 1 deletion(-)
tools/testing/selftests/landlock/fs_test.c +754 -1
@@ -146,7 +146,7 @@ static int remove_path(const char *const path) goto out; }if (unlink (path) &&rmdir (path)) { -if (errno !=ENOENT ) +if (errno !=ENOENT && errno !=ENOTDIR ) err = errno; goto out; }
@@ -1972,6 +1972,721 @@ TEST_F_FORK(layout1, rename_dir)ASSERT_EQ (0 ,rmdir (dir_s1d3)); } +TEST_F_FORK(layout1, reparent_refer) +{ +const struct rule layer1[] = { + { + .path = dir_s1d2, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { + .path = dir_s2d2, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + {}, + }; +int ruleset_fd = +create_ruleset (_metadata,LANDLOCK_ACCESS_FS_REFER , layer1); + +ASSERT_LE (0 , ruleset_fd); +enforce_ruleset (_metadata, ruleset_fd); +ASSERT_EQ (0 ,close (ruleset_fd)); + +ASSERT_EQ (-1 ,rename (dir_s1d2, dir_s2d1)); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,rename (dir_s1d2, dir_s2d2)); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,rename (dir_s1d2, dir_s2d3)); +ASSERT_EQ (EXDEV , errno); + +ASSERT_EQ (-1 ,rename (dir_s1d3, dir_s2d1)); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,rename (dir_s1d3, dir_s2d2)); +ASSERT_EQ (EXDEV , errno); +/* +* Moving should only be allowed when the source and the destination +* parent directory have REFER. +*/ +ASSERT_EQ (-1 ,rename (dir_s1d3, dir_s2d3)); +ASSERT_EQ (ENOTEMPTY , errno); +ASSERT_EQ (0 ,unlink (file1_s2d3)); +ASSERT_EQ (0 ,unlink (file2_s2d3)); +ASSERT_EQ (0 ,rename (dir_s1d3, dir_s2d3)); +} + +TEST_F_FORK(layout1, reparent_link) +{ +const struct rule layer1[] = { + { + .path = dir_s1d2, + .access =LANDLOCK_ACCESS_FS_MAKE_REG , + }, + { + .path = dir_s1d3, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { + .path = dir_s2d2, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { + .path = dir_s2d3, + .access =LANDLOCK_ACCESS_FS_MAKE_REG , + }, + {}, + }; +const int ruleset_fd =create_ruleset ( + _metadata, +LANDLOCK_ACCESS_FS_MAKE_REG |LANDLOCK_ACCESS_FS_REFER , layer1); + +ASSERT_LE (0 , ruleset_fd); +enforce_ruleset (_metadata, ruleset_fd); +ASSERT_EQ (0 ,close (ruleset_fd)); + +ASSERT_EQ (0 ,unlink (file1_s1d1)); +ASSERT_EQ (0 ,unlink (file1_s1d2)); +ASSERT_EQ (0 ,unlink (file1_s1d3)); + +/* Denies linking because of missing MAKE_REG. */ +ASSERT_EQ (-1 ,link (file2_s1d1, file1_s1d1)); +ASSERT_EQ (EACCES , errno); +/* Denies linking because of missing source and destination REFER. */ +ASSERT_EQ (-1 ,link (file1_s2d1, file1_s1d2)); +ASSERT_EQ (EXDEV , errno); +/* Denies linking because of missing source REFER. */ +ASSERT_EQ (-1 ,link (file1_s2d1, file1_s1d3)); +ASSERT_EQ (EXDEV , errno); + +/* Denies linking because of missing MAKE_REG. */ +ASSERT_EQ (-1 ,link (file1_s2d2, file1_s1d1)); +ASSERT_EQ (EACCES , errno); +/* Denies linking because of missing destination REFER. */ +ASSERT_EQ (-1 ,link (file1_s2d2, file1_s1d2)); +ASSERT_EQ (EXDEV , errno); + +/* Allows linking because of REFER and MAKE_REG. */ +ASSERT_EQ (0 ,link (file1_s2d2, file1_s1d3)); +ASSERT_EQ (0 ,unlink (file1_s2d2)); +/* Reverse linking denied because of missing MAKE_REG. */ +ASSERT_EQ (-1 ,link (file1_s1d3, file1_s2d2)); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (0 ,unlink (file1_s2d3)); +/* Checks reverse linking. */ +ASSERT_EQ (0 ,link (file1_s1d3, file1_s2d3)); +ASSERT_EQ (0 ,unlink (file1_s1d3)); + +/* +* This is OK for a file link, but it should not be allowed for a +* directory rename (because of the superset of access rights. +*/ +ASSERT_EQ (0 ,link (file1_s2d3, file1_s1d3)); +ASSERT_EQ (0 ,unlink (file1_s1d3)); + +ASSERT_EQ (-1 ,link (file2_s1d2, file1_s1d3)); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,link (file2_s1d3, file1_s1d2)); +ASSERT_EQ (EXDEV , errno); + +ASSERT_EQ (0 ,link (file2_s1d2, file1_s1d2)); +ASSERT_EQ (0 ,link (file2_s1d3, file1_s1d3)); +} + +TEST_F_FORK(layout1, reparent_rename) +{ +/* Same rules as for reparent_link. */ +const struct rule layer1[] = { + { + .path = dir_s1d2, + .access =LANDLOCK_ACCESS_FS_MAKE_REG , + }, + { + .path = dir_s1d3, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { + .path = dir_s2d2, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { + .path = dir_s2d3, + .access =LANDLOCK_ACCESS_FS_MAKE_REG , + }, + {}, + }; +const int ruleset_fd =create_ruleset ( + _metadata, +LANDLOCK_ACCESS_FS_MAKE_REG |LANDLOCK_ACCESS_FS_REFER , layer1); + +ASSERT_LE (0 , ruleset_fd); +enforce_ruleset (_metadata, ruleset_fd); +ASSERT_EQ (0 ,close (ruleset_fd)); + +ASSERT_EQ (0 ,unlink (file1_s1d2)); +ASSERT_EQ (0 ,unlink (file1_s1d3)); + +/* Denies renaming because of missing MAKE_REG. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file2_s1d1,AT_FDCWD , file1_s1d1, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s1d1,AT_FDCWD , file2_s1d1, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (0 ,unlink (file1_s1d1)); +ASSERT_EQ (-1 ,rename (file2_s1d1, file1_s1d1)); +ASSERT_EQ (EACCES , errno); +/* Even denies same file exchange. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file2_s1d1,AT_FDCWD , file2_s1d1, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* Denies renaming because of missing source and destination REFER. */ +ASSERT_EQ (-1 ,rename (file1_s2d1, file1_s1d2)); +ASSERT_EQ (EXDEV , errno); +/* +* Denies renaming because of missing MAKE_REG, source and destination +* REFER. +*/ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d1,AT_FDCWD , file2_s1d1, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file2_s1d1,AT_FDCWD , file1_s2d1, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* Denies renaming because of missing source REFER. */ +ASSERT_EQ (-1 ,rename (file1_s2d1, file1_s1d3)); +ASSERT_EQ (EXDEV , errno); +/* Denies renaming because of missing MAKE_REG. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d1,AT_FDCWD , file2_s1d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* Denies renaming because of missing MAKE_REG. */ +ASSERT_EQ (-1 ,rename (file1_s2d2, file1_s1d1)); +ASSERT_EQ (EACCES , errno); +/* Denies renaming because of missing destination REFER*/ +ASSERT_EQ (-1 ,rename (file1_s2d2, file1_s1d2)); +ASSERT_EQ (EXDEV , errno); + +/* Denies exchange because of one missing MAKE_REG. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d2,AT_FDCWD , file2_s1d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +/* Allows renaming because of REFER and MAKE_REG. */ +ASSERT_EQ (0 ,rename (file1_s2d2, file1_s1d3)); + +/* Reverse renaming denied because of missing MAKE_REG. */ +ASSERT_EQ (-1 ,rename (file1_s1d3, file1_s2d2)); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (0 ,unlink (file1_s2d3)); +ASSERT_EQ (0 ,rename (file1_s1d3, file1_s2d3)); + +/* Tests reverse renaming. */ +ASSERT_EQ (0 ,rename (file1_s2d3, file1_s1d3)); +ASSERT_EQ (0 ,renameat2 (AT_FDCWD , file2_s2d3,AT_FDCWD , file1_s1d3, +RENAME_EXCHANGE )); +ASSERT_EQ (0 ,rename (file1_s1d3, file1_s2d3)); + +/* +* This is OK for a file rename, but it should not be allowed for a +* directory rename (because of the superset of access rights). +*/ +ASSERT_EQ (0 ,rename (file1_s2d3, file1_s1d3)); +ASSERT_EQ (0 ,rename (file1_s1d3, file1_s2d3)); + +/* +* Tests superset restrictions applied to directories. Not only the +* dir_s2d3's parent (dir_s2d2) should be taken into account but also +* access rights tied to dir_s2d3. dir_s2d2 is missing one access right +* compared to dir_s1d3/file1_s1d3 (MAKE_REG) but it is provided +* directly by the moved dir_s2d3. +*/ +ASSERT_EQ (0 ,rename (dir_s2d3, file1_s1d3)); +ASSERT_EQ (0 ,rename (file1_s1d3, dir_s2d3)); +/* +* The first rename is allowed but not the exchange because dir_s1d3's +* parent (dir_s1d2) doesn't have REFER. +*/ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d3,AT_FDCWD , dir_s1d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_s1d3,AT_FDCWD , file1_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,rename (file1_s2d3, dir_s1d3)); +ASSERT_EQ (EXDEV , errno); + +ASSERT_EQ (-1 ,rename (file2_s1d2, file1_s1d3)); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,rename (file2_s1d3, file1_s1d2)); +ASSERT_EQ (EXDEV , errno); + +/* Renaming in the same directory is always allowed. */ +ASSERT_EQ (0 ,rename (file2_s1d2, file1_s1d2)); +ASSERT_EQ (0 ,rename (file2_s1d3, file1_s1d3)); + +ASSERT_EQ (0 ,unlink (file1_s1d2)); +/* Denies because of missing source MAKE_REG and destination REFER. */ +ASSERT_EQ (-1 ,rename (dir_s2d3, file1_s1d2)); +ASSERT_EQ (EXDEV , errno); + +ASSERT_EQ (0 ,unlink (file1_s1d3)); +/* Denies because of missing source MAKE_REG and REFER. */ +ASSERT_EQ (-1 ,rename (dir_s2d2, file1_s1d3)); +ASSERT_EQ (EXDEV , errno); +} + +static void +reparent_exdev_layers_enforce1 (struct __test_metadata *const _metadata) +{ +const struct rule layer1[] = { + { + .path = dir_s1d2, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { +/* Interesting for the layer2 tests. */ + .path = dir_s1d3, + .access =LANDLOCK_ACCESS_FS_MAKE_REG , + }, + { + .path = dir_s2d2, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { + .path = dir_s2d3, + .access =LANDLOCK_ACCESS_FS_MAKE_REG , + }, + {}, + }; +const int ruleset_fd =create_ruleset ( + _metadata, +LANDLOCK_ACCESS_FS_MAKE_REG |LANDLOCK_ACCESS_FS_REFER , layer1); + +ASSERT_LE (0 , ruleset_fd); +enforce_ruleset (_metadata, ruleset_fd); +ASSERT_EQ (0 ,close (ruleset_fd)); +} + +static void +reparent_exdev_layers_enforce2 (struct __test_metadata *const _metadata) +{ +const struct rule layer2[] = { + { + .path = dir_s2d3, + .access =LANDLOCK_ACCESS_FS_MAKE_DIR , + }, + {}, + }; +/* +* Same checks as before but with a second layer and a new MAKE_DIR +* rule (and no explicit handling of REFER). +*/ +const int ruleset_fd = +create_ruleset (_metadata,LANDLOCK_ACCESS_FS_MAKE_DIR , layer2); + +ASSERT_LE (0 , ruleset_fd); +enforce_ruleset (_metadata, ruleset_fd); +ASSERT_EQ (0 ,close (ruleset_fd)); +} + +TEST_F_FORK(layout1, reparent_exdev_layers_rename1) +{ +ASSERT_EQ (0 ,unlink (file1_s2d2)); +ASSERT_EQ (0 ,unlink (file1_s2d3)); + +reparent_exdev_layers_enforce1 (_metadata); + +/* +* Moving the dir_s1d3 directory below dir_s2d2 is allowed by Landlock +* because it doesn't inherit new access rights. +*/ +ASSERT_EQ (0 ,rename (dir_s1d3, file1_s2d2)); +ASSERT_EQ (0 ,rename (file1_s2d2, dir_s1d3)); + +/* +* Moving the dir_s1d3 directory below dir_s2d3 is allowed, even if it +* gets a new inherited access rights (MAKE_REG), because MAKE_REG is +* already allowed for dir_s1d3. +*/ +ASSERT_EQ (0 ,rename (dir_s1d3, file1_s2d3)); +ASSERT_EQ (0 ,rename (file1_s2d3, dir_s1d3)); + +/* +* However, moving the file1_s1d3 file below dir_s2d3 is allowed +* because it cannot inherit MAKE_REG right (which is dedicated to +* directories). +*/ +ASSERT_EQ (0 ,rename (file1_s1d3, file1_s2d3)); + +reparent_exdev_layers_enforce2 (_metadata); + +/* +* Moving the dir_s1d3 directory below dir_s2d2 is now denied because +* MAKE_DIR is not tied to dir_s2d2. +*/ +ASSERT_EQ (-1 ,rename (dir_s1d3, file1_s2d2)); +ASSERT_EQ (EACCES , errno); + +/* +* Moving the dir_s1d3 directory below dir_s2d3 is forbidden because it +* would grants MAKE_REG and MAKE_DIR rights to it. +*/ +ASSERT_EQ (-1 ,rename (dir_s1d3, file1_s2d3)); +ASSERT_EQ (EXDEV , errno); + +/* +* However, moving the file2_s1d3 file below dir_s2d3 is allowed +* because it cannot inherit MAKE_REG nor MAKE_DIR rights (which are +* dedicated to directories). +*/ +ASSERT_EQ (0 ,rename (file2_s1d3, file1_s2d3)); +} + +TEST_F_FORK(layout1, reparent_exdev_layers_rename2) +{ +reparent_exdev_layers_enforce1 (_metadata); + +/* Checks EACCES predominance over EXDEV. */ +ASSERT_EQ (-1 ,rename (file1_s1d1, file1_s2d2)); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,rename (file1_s1d2, file1_s2d2)); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,rename (file1_s1d1, file1_s2d3)); +ASSERT_EQ (EXDEV , errno); +/* Modify layout! */ +ASSERT_EQ (0 ,rename (file1_s1d2, file1_s2d3)); + +/* Without REFER source. */ +ASSERT_EQ (-1 ,rename (dir_s1d1, file1_s2d2)); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,rename (dir_s1d2, file1_s2d2)); +ASSERT_EQ (EXDEV , errno); + +reparent_exdev_layers_enforce2 (_metadata); + +/* Checks EACCES predominance over EXDEV. */ +ASSERT_EQ (-1 ,rename (file1_s1d1, file1_s2d2)); +ASSERT_EQ (EACCES , errno); +/* Checks with actual file2_s1d2. */ +ASSERT_EQ (-1 ,rename (file2_s1d2, file1_s2d2)); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,rename (file1_s1d1, file1_s2d3)); +ASSERT_EQ (EXDEV , errno); +/* Modify layout! */ +ASSERT_EQ (0 ,rename (file2_s1d2, file1_s2d3)); + +/* Without REFER source, EACCES wins over EXDEV. */ +ASSERT_EQ (-1 ,rename (dir_s1d1, file1_s2d2)); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,rename (dir_s1d2, file1_s2d2)); +ASSERT_EQ (EACCES , errno); +} + +TEST_F_FORK(layout1, reparent_exdev_layers_exchange1) +{ +const char *const dir_file1_s1d2 = file1_s1d2, *const dir_file2_s2d3 = + file2_s2d3; + +ASSERT_EQ (0 ,unlink (file1_s1d2)); +ASSERT_EQ (0 ,mkdir (file1_s1d2,0700 )); +ASSERT_EQ (0 ,unlink (file2_s2d3)); +ASSERT_EQ (0 ,mkdir (file2_s2d3,0700 )); + +reparent_exdev_layers_enforce1 (_metadata); + +/* Error predominance with file exchange: returns EXDEV and EACCES. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s1d1,AT_FDCWD , file1_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d3,AT_FDCWD , file1_s1d1, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* +* Checks with directories which creation could be allowed, but denied +* because of access rights that would be inherited. +*/ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_file1_s1d2,AT_FDCWD , + dir_file2_s2d3,RENAME_EXCHANGE )); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_file2_s2d3,AT_FDCWD , + dir_file1_s1d2,RENAME_EXCHANGE )); +ASSERT_EQ (EXDEV , errno); + +/* Checks with same access rights. */ +ASSERT_EQ (0 ,renameat2 (AT_FDCWD , dir_s1d3,AT_FDCWD , dir_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (0 ,renameat2 (AT_FDCWD , dir_s2d3,AT_FDCWD , dir_s1d3, +RENAME_EXCHANGE )); + +/* Checks with different (child-only) access rights. */ +ASSERT_EQ (0 ,renameat2 (AT_FDCWD , dir_s2d3,AT_FDCWD , dir_file1_s1d2, +RENAME_EXCHANGE )); +ASSERT_EQ (0 ,renameat2 (AT_FDCWD , dir_file1_s1d2,AT_FDCWD , dir_s2d3, +RENAME_EXCHANGE )); + +/* +* Checks that exchange between file and directory are consistent. +* +* Moving a file (file1_s2d2) to a directory which only grants more +* directory-related access rights is allowed, and at the same time +* moving a directory (dir_file2_s2d3) to another directory which +* grants less access rights is allowed too. +* +* See layout1.reparent_exdev_layers_exchange3 for inverted arguments. +*/ +ASSERT_EQ (0 ,renameat2 (AT_FDCWD , file1_s2d2,AT_FDCWD , dir_file2_s2d3, +RENAME_EXCHANGE )); +/* +* However, moving back the directory is denied because it would get +* more access rights than the current state and because file creation +* is forbidden (in dir_s2d2). +*/ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_file2_s2d3,AT_FDCWD , file1_s2d2, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d2,AT_FDCWD , dir_file2_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +reparent_exdev_layers_enforce2 (_metadata); + +/* Error predominance with file exchange: returns EXDEV and EACCES. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s1d1,AT_FDCWD , file1_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d3,AT_FDCWD , file1_s1d1, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* Checks with directories which creation is now denied. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_file1_s1d2,AT_FDCWD , + dir_file2_s2d3,RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_file2_s2d3,AT_FDCWD , + dir_file1_s1d2,RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* Checks with different (child-only) access rights. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_s1d3,AT_FDCWD , dir_s2d3, +RENAME_EXCHANGE )); +/* Denied because of MAKE_DIR. */ +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_s2d3,AT_FDCWD , dir_s1d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* Checks with different (child-only) access rights. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_s2d3,AT_FDCWD , dir_file1_s1d2, +RENAME_EXCHANGE )); +/* Denied because of MAKE_DIR. */ +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_file1_s1d2,AT_FDCWD , dir_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* See layout1.reparent_exdev_layers_exchange2 for complement. */ +} + +TEST_F_FORK(layout1, reparent_exdev_layers_exchange2) +{ +const char *const dir_file2_s2d3 = file2_s2d3; + +ASSERT_EQ (0 ,unlink (file2_s2d3)); +ASSERT_EQ (0 ,mkdir (file2_s2d3,0700 )); + +reparent_exdev_layers_enforce1 (_metadata); +reparent_exdev_layers_enforce2 (_metadata); + +/* Checks that exchange between file and directory are consistent. */ +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d2,AT_FDCWD , dir_file2_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_file2_s2d3,AT_FDCWD , file1_s2d2, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +} + +TEST_F_FORK(layout1, reparent_exdev_layers_exchange3) +{ +const char *const dir_file2_s2d3 = file2_s2d3; + +ASSERT_EQ (0 ,unlink (file2_s2d3)); +ASSERT_EQ (0 ,mkdir (file2_s2d3,0700 )); + +reparent_exdev_layers_enforce1 (_metadata); + +/* +* Checks that exchange between file and directory are consistent, +* including with inverted arguments (see +* layout1.reparent_exdev_layers_exchange1). +*/ +ASSERT_EQ (0 ,renameat2 (AT_FDCWD , dir_file2_s2d3,AT_FDCWD , file1_s2d2, +RENAME_EXCHANGE )); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d2,AT_FDCWD , dir_file2_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , dir_file2_s2d3,AT_FDCWD , file1_s2d2, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +} + +TEST_F_FORK(layout1, reparent_remove) +{ +const struct rule layer1[] = { + { + .path = dir_s1d1, + .access =LANDLOCK_ACCESS_FS_REFER | +LANDLOCK_ACCESS_FS_REMOVE_DIR , + }, + { + .path = dir_s1d2, + .access =LANDLOCK_ACCESS_FS_REMOVE_FILE , + }, + { + .path = dir_s2d1, + .access =LANDLOCK_ACCESS_FS_REFER | +LANDLOCK_ACCESS_FS_REMOVE_FILE , + }, + {}, + }; +const int ruleset_fd =create_ruleset ( + _metadata, +LANDLOCK_ACCESS_FS_REFER |LANDLOCK_ACCESS_FS_REMOVE_DIR | +LANDLOCK_ACCESS_FS_REMOVE_FILE , + layer1); + +ASSERT_LE (0 , ruleset_fd); +enforce_ruleset (_metadata, ruleset_fd); +ASSERT_EQ (0 ,close (ruleset_fd)); + +/* Access denied because of wrong/swapped remove file/dir. */ +ASSERT_EQ (-1 ,rename (file1_s1d1, dir_s2d2)); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,rename (dir_s2d2, file1_s1d1)); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s1d1,AT_FDCWD , dir_s2d2, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s1d1,AT_FDCWD , dir_s2d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); + +/* Access allowed thanks to the matching rights. */ +ASSERT_EQ (-1 ,rename (file1_s2d1, dir_s1d2)); +ASSERT_EQ (EISDIR , errno); +ASSERT_EQ (-1 ,rename (dir_s1d2, file1_s2d1)); +ASSERT_EQ (ENOTDIR , errno); +ASSERT_EQ (-1 ,rename (dir_s1d3, file1_s2d1)); +ASSERT_EQ (ENOTDIR , errno); +ASSERT_EQ (0 ,unlink (file1_s2d1)); +ASSERT_EQ (0 ,unlink (file1_s1d3)); +ASSERT_EQ (0 ,unlink (file2_s1d3)); +ASSERT_EQ (0 ,rename (dir_s1d3, file1_s2d1)); + +/* Effectively removes a file and a directory by exchanging them. */ +ASSERT_EQ (0 ,mkdir (dir_s1d3,0700 )); +ASSERT_EQ (0 ,renameat2 (AT_FDCWD , file1_s2d2,AT_FDCWD , dir_s1d3, +RENAME_EXCHANGE )); +ASSERT_EQ (-1 ,renameat2 (AT_FDCWD , file1_s2d2,AT_FDCWD , dir_s1d3, +RENAME_EXCHANGE )); +ASSERT_EQ (EACCES , errno); +} + +TEST_F_FORK(layout1, reparent_dom_superset) +{ +const struct rule layer1[] = { + { + .path = dir_s1d2, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { + .path = file1_s1d2, + .access =LANDLOCK_ACCESS_FS_EXECUTE , + }, + { + .path = dir_s1d3, + .access =LANDLOCK_ACCESS_FS_MAKE_SOCK | +LANDLOCK_ACCESS_FS_EXECUTE , + }, + { + .path = dir_s2d2, + .access =LANDLOCK_ACCESS_FS_REFER | +LANDLOCK_ACCESS_FS_EXECUTE | +LANDLOCK_ACCESS_FS_MAKE_SOCK , + }, + { + .path = dir_s2d3, + .access =LANDLOCK_ACCESS_FS_READ_FILE | +LANDLOCK_ACCESS_FS_MAKE_FIFO , + }, + {}, + }; +int ruleset_fd =create_ruleset (_metadata, +LANDLOCK_ACCESS_FS_REFER | +LANDLOCK_ACCESS_FS_EXECUTE | +LANDLOCK_ACCESS_FS_MAKE_SOCK | +LANDLOCK_ACCESS_FS_READ_FILE | +LANDLOCK_ACCESS_FS_MAKE_FIFO , + layer1); + +ASSERT_LE (0 , ruleset_fd); +enforce_ruleset (_metadata, ruleset_fd); +ASSERT_EQ (0 ,close (ruleset_fd)); + +ASSERT_EQ (-1 ,rename (file1_s1d2, file1_s2d1)); +ASSERT_EQ (EXDEV , errno); +/* +* Moving file1_s1d2 beneath dir_s2d3 would grant it the READ_FILE +* access right. +*/ +ASSERT_EQ (-1 ,rename (file1_s1d2, file1_s2d3)); +ASSERT_EQ (EXDEV , errno); +/* +* Moving file1_s1d2 should be allowed even if dir_s2d2 grants a +* superset of access rights compared to dir_s1d2, because file1_s1d2 +* already has these access rights anyway. +*/ +ASSERT_EQ (0 ,rename (file1_s1d2, file1_s2d2)); +ASSERT_EQ (0 ,rename (file1_s2d2, file1_s1d2)); + +ASSERT_EQ (-1 ,rename (dir_s1d3, file1_s2d1)); +ASSERT_EQ (EXDEV , errno); +/* +* Moving dir_s1d3 beneath dir_s2d3 would grant it the MAKE_FIFO access +* right. +*/ +ASSERT_EQ (-1 ,rename (dir_s1d3, file1_s2d3)); +ASSERT_EQ (EXDEV , errno); +/* +* Moving dir_s1d3 should be allowed even if dir_s2d2 grants a superset +* of access rights compared to dir_s1d2, because dir_s1d3 already has +* these access rights anyway. +*/ +ASSERT_EQ (0 ,rename (dir_s1d3, file1_s2d2)); +ASSERT_EQ (0 ,rename (file1_s2d2, dir_s1d3)); + +/* +* Moving file1_s2d3 beneath dir_s1d2 is allowed, but moving it back +* will be denied because the new inherited access rights from dir_s1d2 +* will be less than the destination (original) dir_s2d3. This is a +* sinkhole scenario where we cannot move back files or directories. +*/ +ASSERT_EQ (0 ,rename (file1_s2d3, file2_s1d2)); +ASSERT_EQ (-1 ,rename (file2_s1d2, file1_s2d3)); +ASSERT_EQ (EXDEV , errno); +ASSERT_EQ (0 ,unlink (file2_s1d2)); +ASSERT_EQ (0 ,unlink (file2_s2d3)); +/* +* Checks similar directory one-way move: dir_s2d3 loses EXECUTE and +* MAKE_SOCK which were inherited from dir_s1d3. +*/ +ASSERT_EQ (0 ,rename (dir_s2d3, file2_s1d2)); +ASSERT_EQ (-1 ,rename (file2_s1d2, dir_s2d3)); +ASSERT_EQ (EXDEV , errno); +} + TEST_F_FORK(layout1, remove_dir) {const struct rule rules[] = {
@@ -2520,6 +3235,44 @@ TEST_F_FORK(layout1_bind, same_content_same_file)ASSERT_EQ (EACCES ,test_open (bind_file1_s1d3,O_WRONLY )); } +TEST_F_FORK(layout1_bind, reparent_cross_mount) +{ +const struct rule layer1[] = { + { +/* dir_s2d1 is beneath the dir_s2d2 mount point. */ + .path = dir_s2d1, + .access =LANDLOCK_ACCESS_FS_REFER , + }, + { + .path = bind_dir_s1d3, + .access =LANDLOCK_ACCESS_FS_EXECUTE , + }, + {}, + }; +int ruleset_fd =create_ruleset ( + _metadata, +LANDLOCK_ACCESS_FS_REFER |LANDLOCK_ACCESS_FS_EXECUTE , layer1); + +ASSERT_LE (0 , ruleset_fd); +enforce_ruleset (_metadata, ruleset_fd); +ASSERT_EQ (0 ,close (ruleset_fd)); + +/* Checks basic denied move. */ +ASSERT_EQ (-1 ,rename (file1_s1d1, file1_s1d2)); +ASSERT_EQ (EXDEV , errno); + +/* Checks real cross-mount move (Landlock is not involved). */ +ASSERT_EQ (-1 ,rename (file1_s2d1, file1_s2d2)); +ASSERT_EQ (EXDEV , errno); + +/* Checks move that will give more accesses. */ +ASSERT_EQ (-1 ,rename (file1_s2d2, bind_file1_s1d3)); +ASSERT_EQ (EXDEV , errno); + +/* Checks legitimate downgrade move. */ +ASSERT_EQ (0 ,rename (bind_file1_s1d3, file1_s2d2)); +} +#define LOWER_BASE TMP_DIR "/lower"#define LOWER_DATA LOWER_BASE "/data"static const char lower_fl1[] =LOWER_DATA "/fl1" ;
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 9/12 samples/landlock: Add support for file reparenting
In reply to Mickaël SalaünAdd LANDLOCK_ACCESS_FS_REFER to the "roughly write" access rights and leverage the Landlock ABI version to only try to enforce it if it is supported by the running kernel.
---
Changes since v2:
* Format with clang-format and rebase.
Changes since v1:
* Add Reviewed-by: Paul Moore.
--- samples/landlock/sandboxer.c | 40 ++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 13 deletions(-)
samples/landlock/sandboxer.c +27 -13
@@ -159,7 +159,11 @@ static int populate_ruleset(const char *const env_var, const int ruleset_fd,LANDLOCK_ACCESS_FS_MAKE_SOCK | \LANDLOCK_ACCESS_FS_MAKE_FIFO | \LANDLOCK_ACCESS_FS_MAKE_BLOCK | \ - LANDLOCK_ACCESS_FS_MAKE_SYM) +LANDLOCK_ACCESS_FS_MAKE_SYM | \ + LANDLOCK_ACCESS_FS_REFER) + +#define ACCESS_ABI_2 ( \ +LANDLOCK_ACCESS_FS_REFER )/* clang-format on */
@@ -167,10 +171,11 @@ int main(const int argc, char *const argv[], char *const *const envp) {const char *cmd_path;char *const *cmd_argv; -int ruleset_fd; +int ruleset_fd, abi; +__u64 access_fs_ro =ACCESS_FS_ROUGHLY_READ , + access_fs_rw =ACCESS_FS_ROUGHLY_READ |ACCESS_FS_ROUGHLY_WRITE ;struct landlock_ruleset_attr ruleset_attr = { - .handled_access_fs =ACCESS_FS_ROUGHLY_READ | -ACCESS_FS_ROUGHLY_WRITE , + .handled_access_fs = access_fs_rw, };if (argc <2 ) {
@@ -196,12 +201,11 @@ int main(const int argc, char *const argv[], char *const *const envp)return 1 ; } - ruleset_fd = -landlock_create_ruleset (&ruleset_attr,sizeof (ruleset_attr),0 ); -if (ruleset_fd <0 ) { + abi =landlock_create_ruleset (NULL ,0 ,LANDLOCK_CREATE_RULESET_VERSION ); +if (abi <0 ) {const int err = errno; -perror ("Failed to create a ruleset" ); +perror ("Failed to check Landlock compatibility" );switch (err) {case ENOSYS : fprintf(stderr,
@@ -221,13 +225,23 @@ int main(const int argc, char *const argv[], char *const *const envp) }return 1 ; } -if (populate_ruleset (ENV_FS_RO_NAME , ruleset_fd, -ACCESS_FS_ROUGHLY_READ )) { +/* Best-effort security. */ +if (abi <2 ) { + ruleset_attr.handled_access_fs &= ~ACCESS_ABI_2 ; + access_fs_ro &= ~ACCESS_ABI_2 ; + access_fs_rw &= ~ACCESS_ABI_2 ; + } + + ruleset_fd = +landlock_create_ruleset (&ruleset_attr,sizeof (ruleset_attr),0 ); +if (ruleset_fd <0 ) { +perror ("Failed to create a ruleset" ); +return 1 ; + } +if (populate_ruleset (ENV_FS_RO_NAME , ruleset_fd, access_fs_ro)) { goto err_close_ruleset; } -if (populate_ruleset (ENV_FS_RW_NAME , ruleset_fd, -ACCESS_FS_ROUGHLY_READ | -ACCESS_FS_ROUGHLY_WRITE )) { +if (populate_ruleset (ENV_FS_RW_NAME , ruleset_fd, access_fs_rw)) { goto err_close_ruleset; }if (prctl (PR_SET_NO_NEW_PRIVS ,1 ,0 ,0 ,0 )) {
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 10/12 landlock: Document LANDLOCK_ACCESS_FS_REFER and ABI versioning
In reply to Mickaël SalaünAdd LANDLOCK_ACCESS_FS_REFER in the example and properly check to only use it if the current kernel support it thanks to the Landlock ABI version.
Move the file renaming and linking limitation to a new "Previous limitations" section.
Improve documentation about the backward and forward compatibility, including the rational for ruleset's handled_access_fs.
Update the document date.
---
Changes since v2:
* Fix spelling spotted by Paul.
* Explain a bit more the renaming and linking constraint alternative (previous limitations), which is implemented with LANDLOCK_ACCESS_FS_REFER.
* Update date.
Changes since v1:
* Add Reviewed-by: Paul Moore.
* Update date.
--- Documentation/userspace-api/landlock.rst | 126 +++++++++++++++++++---- 1 file changed, 106 insertions(+), 20 deletions(-)
Documentation/userspace-api/landlock.rst +106 -20
@@ -8,7 +8,7 @@ Landlock: unprivileged access control ===================================== :Author: Mickaël Salaün -:Date: March 2021 +:Date: May 2022 The goal of Landlock is to enable to restrict ambient rights (e.g. global filesystem access) for a set of processes. Because Landlock is a stackable
@@ -29,14 +29,15 @@ the thread enforcing it, and its future children. Defining and enforcing a security policy ---------------------------------------- -We first need to create the ruleset that will contain our rules. For this +We first need to define the ruleset that will contain our rules. For this example, the ruleset will contain rules that only allow read actions, but write actions will be denied. The ruleset then needs to handle both of these kind of -actions. +actions. This is required for backward and forward compatibility (i.e. the +kernel and user space may not know each other's supported restrictions), hence +the need to be explicit about the denied-by-default access rights. .. code-block:: c - int ruleset_fd; struct landlock_ruleset_attr ruleset_attr = { .handled_access_fs = LANDLOCK_ACCESS_FS_EXECUTE |
@@ -51,9 +52,34 @@ actions. LANDLOCK_ACCESS_FS_MAKE_SOCK | LANDLOCK_ACCESS_FS_MAKE_FIFO | LANDLOCK_ACCESS_FS_MAKE_BLOCK | - LANDLOCK_ACCESS_FS_MAKE_SYM, + LANDLOCK_ACCESS_FS_MAKE_SYM | + LANDLOCK_ACCESS_FS_REFER, }; +Because we may not know on which kernel version an application will be +executed, it is safer to follow a best-effort security approach. Indeed, we +should try to protect users as much as possible whatever the kernel they are +using. To avoid binary enforcement (i.e. either all security features or +none), we can leverage a dedicated Landlock command to get the current version +of the Landlock ABI and adapt the handled accesses. Let's check if we should +remove the `LANDLOCK_ACCESS_FS_REFER` access right which is only supported +starting with the second version of the ABI. + +.. code-block:: c + + int abi; + + abi = landlock_create_ruleset(NULL, 0, LANDLOCK_CREATE_RULESET_VERSION); + if (abi < 2) { + ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_REFER; + } + +This enables to create an inclusive ruleset that will contain our rules. + +.. code-block:: c + + int ruleset_fd; + ruleset_fd = landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0); if (ruleset_fd < 0) { perror("Failed to create a ruleset");
@@ -92,6 +118,11 @@ descriptor. return 1; } +It may also be required to create rules following the same logic as explained +for the ruleset creation, by filtering access rights according to the Landlock +ABI version. In this example, this is not required because +`LANDLOCK_ACCESS_FS_REFER` is not allowed by any rule. + We now have a ruleset with one rule allowing read access to ``/usr`` while denying all other handled accesses for the filesystem. The next step is to restrict the current thread from gaining more privileges (e.g. thanks to a SUID
@@ -192,6 +223,56 @@ To be allowed to use :manpage:`ptrace(2)` and related syscalls on a target process, a sandboxed process should have a subset of the target process rules, which means the tracee must be in a sub-domain of the tracer. +Compatibility +============= + +Backward and forward compatibility +---------------------------------- + +Landlock is designed to be compatible with past and future versions of the +kernel. This is achieved thanks to the system call attributes and the +associated bitflags, particularly the ruleset's `handled_access_fs`. Making +handled access right explicit enables the kernel and user space to have a clear +contract with each other. This is required to make sure sandboxing will not +get stricter with a system update, which could break applications. + +Developers can subscribe to the `Landlock mailing list +<https://subspace.kernel.org/lists.linux.dev.html>`_ to knowingly update and +test their applications with the latest available features. In the interest of +users, and because they may use different kernel versions, it is strongly +encouraged to follow a best-effort security approach by checking the Landlock +ABI version at runtime and only enforcing the supported features. + +Landlock ABI versions +--------------------- + +The Landlock ABI version can be read with the sys_landlock_create_ruleset() +system call: + +.. code-block:: c + + int abi; + + abi = landlock_create_ruleset(NULL, 0, LANDLOCK_CREATE_RULESET_VERSION); + if (abi < 0) { + switch (errno) { + case ENOSYS: + printf("Landlock is not supported by the current kernel.\n"); + break; + case EOPNOTSUPP: + printf("Landlock is currently disabled.\n"); + break; + } + return 0; + } + if (abi >= 2) { + printf("Landlock supports LANDLOCK_ACCESS_FS_REFER.\n"); + } + +The following kernel interfaces are implicitly supported by the first ABI +version. Features only supported from a specific version are explicitly marked +as such. + Kernel interface ================
@@ -228,21 +309,6 @@ Enforcing a ruleset Current limitations =================== -File renaming and linking -------------------------- - -Because Landlock targets unprivileged access controls, it is needed to properly -handle composition of rules. Such property also implies rules nesting. -Properly handling multiple layers of ruleset, each one of them able to restrict -access to files, also implies to inherit the ruleset restrictions from a parent -to its hierarchy. Because files are identified and restricted by their -hierarchy, moving or linking a file from one directory to another implies to -propagate the hierarchy constraints. To protect against privilege escalations -through renaming or linking, and for the sake of simplicity, Landlock currently -limits linking and renaming to the same directory. Future Landlock evolutions -will enable more flexibility for renaming and linking, with dedicated ruleset -flags. - Filesystem topology modification --------------------------------
@@ -281,6 +347,26 @@ Memory usage Kernel memory allocated to create rulesets is accounted and can be restricted by the Documentation/admin-guide/cgroup-v1/memory.rst. +Previous limitations +==================== + +File renaming and linking (ABI 1) +--------------------------------- + +Because Landlock targets unprivileged access controls, it needs to properly +handle composition of rules. Such property also implies rules nesting. +Properly handling multiple layers of rulesets, each one of them able to +restrict access to files, also implies inheritance of the ruleset restrictions +from a parent to its hierarchy. Because files are identified and restricted by +their hierarchy, moving or linking a file from one directory to another implies +propagation of the hierarchy constraints, or restriction of these actions +according to the potentially lost constraints. To protect against privilege +escalations through renaming or linking, and for the sake of simplicity, +Landlock previously limited linking and renaming to the same directory. +Starting with the Landlock ABI version 2, it is now possible to securely +control renaming and linking thanks to the new `LANDLOCK_ACCESS_FS_REFER` +access right. + Questions and answers =====================
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 11/12 landlock: Document good practices about filesystem policies
In reply to Mickaël SalaünExplain how to set access rights per hierarchy in an efficient and safe way, especially with the LANDLOCK_ACCESS_FS_REFER side effect (i.e. partial ordering and constraints for access rights per hierarchy).
---
Changes since v1:
* Add more explanation in the commit message.
Changes since v1:
* Add Reviewed-by: Paul Moore.
--- Documentation/userspace-api/landlock.rst | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
Documentation/userspace-api/landlock.rst +21 -0
@@ -156,6 +156,27 @@ ruleset. Full working code can be found in `samples/landlock/sandboxer.c`_. +Good practices +-------------- + +It is recommended setting access rights to file hierarchy leaves as much as +possible. For instance, it is better to be able to have ``~/doc/`` as a +read-only hierarchy and ``~/tmp/`` as a read-write hierarchy, compared to +``~/`` as a read-only hierarchy and ``~/tmp/`` as a read-write hierarchy. +Following this good practice leads to self-sufficient hierarchies that don't +depend on their location (i.e. parent directories). This is particularly +relevant when we want to allow linking or renaming. Indeed, having consistent +access rights per directory enables to change the location of such directory +without relying on the destination directory access rights (except those that +are required for this operation, see `LANDLOCK_ACCESS_FS_REFER` documentation). +Having self-sufficient hierarchies also helps to tighten the required access +rights to the minimal set of data. This also helps avoid sinkhole directories, +i.e. directories where data can be linked to but not linked from. However, +this depends on data organization, which might not be controlled by developers. +In this case, granting read-write access to ``~/tmp/``, instead of write-only +access, would potentially allow to move ``~/tmp/`` to a non-readable directory +and still keep the ability to list the content of ``~/tmp/``. + Layers of file path access rights ---------------------------------
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerPATCH v3 12/12 landlock: Add design choices documentation for filesystem access rights
In reply to Mickaël SalaünSummarize the rationale of filesystem access rights according to the file type.
Update the document date.
---
Changes since v2:
* Add more explanation in the commit message.
* Update date.
Changes since v1:
* Add Reviewed-by: Paul Moore.
* Update date.
--- Documentation/security/landlock.rst | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)
Documentation/security/landlock.rst +16 -1
@@ -7,7 +7,7 @@ Landlock LSM: kernel documentation ================================== :Author: Mickaël Salaün -:Date: March 2021 +:Date: May 2022 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,
@@ -42,6 +42,21 @@ Guiding principles for safe access controls * Computation related to Landlock operations (e.g. enforcing a ruleset) shall only impact the processes requesting them. +Design choices +============== + +Filesystem access rights +------------------------ + +All access rights are tied to an inode and what can be accessed through it. +Reading the content of a directory doesn't imply to be allowed to read the +content of a listed inode. Indeed, a file name is local to its parent +directory, and an inode can be referenced by multiple file names thanks to +(hard) links. Being able to unlink a file only has a direct impact on the +directory, not the unlinked inode. This is the reason why +`LANDLOCK_ACCESS_FS_REMOVE_FILE` or `LANDLOCK_ACCESS_FS_REFER` are not allowed +to be tied to files but only to directories. + Tests =====
Signature · 1 line
2.35.1
Mickaël Salaün
maintainerThe four related patch series are available here: https://git.kernel.org/pub/scm/linux/kernel/git/mic/linux.git/log/?h=landlock-wip
Quoted 99 lines · Mickaël Salaün
Hi,
This third patch series is mostly a rebase with some whitespace changes because of clang-format. There is also some new "
unlikely()" calls and minor code cleanup.Test coverage for
security/landlockwas 94.4% of 504 lines (with the previous patch series), and it is now 95.4% of 604 lines according to gcc/gcov-11.Problem
=======One of the most annoying limitations of Landlock is that sandboxed processes can only link and rename files to the same directory (i.e. file reparenting is always denied). Indeed, because of the unprivileged nature of Landlock, file hierarchy are identified thanks to ephemeral inode tagging, which may cause arbitrary renaming and linking to change the security policy in an unexpected way.
Solution
========This patch series brings a new access right,
LANDLOCK_ACCESS_FS_REFER, which enables to allow safe file linking and renaming. In a nutshell, Landlock checks that the inherited access rights of a moved or renamed file cannot increase but only reduce. Eleven new test suits cover file renaming and linking, which improves test coverage.The documentation and the tutorial is extended with this new access right, along with more explanations about backward and forward compatibility, good practices, and a bit about the current access rights rational.
While developing this new feature, I also found an issue with the current implementation of Landlock. In some (rare) cases, sandboxed processes may be more restricted than intended. Indeed, because of the current way to check file hierarchy access rights, composition of rules may be incomplete when requesting multiple accesses at the same time. This is fixed with a dedicated patch involving some refactoring. A new test suite checks relevant new edge cases.
As a side effect, and to limit the increased use of the stack, I reduced the number of Landlock nested domains from 64 to 16. I think this should be more than enough for legitimate use cases, but feel free to challenge this decision with real and legitimate use cases.
Additionally, a new dedicated syzkaller test has been developed to cover new paths.
This patch series is based on and was developed with some complementary new tests sent in a standalone patch series:
https://lore.kernel.org/r/[email protected]Previous versions:
v2: https://lore.kernel.org/r/[email protected]
v1: https://lore.kernel.org/r/[email protected]Regards,
Mickaël Salaün (12):
landlock: Defineaccess_mask_tto enforce a consistent access mask
size
landlock: Reduce the maximum number of layers to 16
landlock: Createfind_rule()fromunmask_layers()
landlock: Fix same-layer rule unions
landlock: Move filesystem helpers and add a new one
LSM: Remove doublepath_renamehook calls forRENAME_EXCHANGE
landlock: Add support for file reparenting with
LANDLOCK_ACCESS_FS_REFER
selftests/landlock: Add 11 new test suites dedicated to file
reparenting
samples/landlock: Add support for file reparenting
landlock: DocumentLANDLOCK_ACCESS_FS_REFERand ABI versioning
landlock: Document good practices about filesystem policies
landlock: Add design choices documentation for filesystem access
rightsDocumentation/security/landlock.rst | 17 +- Documentation/userspace-api/landlock.rst | 151 ++- include/linux/lsm_hook_defs.h | 2 +- include/linux/lsm_hooks.h | 1 + include/uapi/linux/landlock.h | 27 +- samples/landlock/sandboxer.c | 40 +- security/apparmor/lsm.c | 30 +- security/landlock/fs.c | 771 ++++++++++--- security/landlock/fs.h | 2 +- security/landlock/limits.h | 6 +- security/landlock/ruleset.c | 6 +- security/landlock/ruleset.h | 22 +- security/landlock/syscalls.c | 2 +- security/security.c | 9 +- security/tomoyo/tomoyo.c | 11 +- tools/testing/selftests/landlock/base_test.c | 2 +- tools/testing/selftests/landlock/fs_test.c | 1039 ++++++++++++++++-- 17 files changed, 1853 insertions(+), 285 deletions(-)base-commit:
4b0cdb0cf6eefa7521322007931ccfb7edc96c53