forked from torvalds/linux
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
A Landlock object enables to identify a kernel object (e.g. an inode). A Landlock rule is a set of access rights allowed on an object. Rules are grouped in rulesets that may be tied to a set of processes (i.e. subjects) to enforce a scoped access-control (i.e. a domain). Because Landlock's goal is to empower any process (especially unprivileged ones) to sandbox themselves, we cannot rely on a system-wide object identification such as file extended attributes. Indeed, we need innocuous, composable and modular access-controls. The main challenge with these constraints is to identify kernel objects while this identification is useful (i.e. when a security policy makes use of this object). But this identification data should be freed once no policy is using it. This ephemeral tagging should not and may not be written in the filesystem. We then need to manage the lifetime of a rule according to the lifetime of its objects. To avoid a global lock, this implementation make use of RCU and counters to safely reference objects. A following commit uses this generic object management for inodes. Cc: James Morris <[email protected]> Signed-off-by: Mickaël Salaün <[email protected]> Reviewed-by: Jann Horn <[email protected]> Acked-by: Serge Hallyn <[email protected]> Reviewed-by: Kees Cook <[email protected]> Link: https://lore.kernel.org/r/[email protected] Signed-off-by: James Morris <[email protected]>
- Loading branch information
Showing
7 changed files
with
195 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
|
@@ -9997,6 +9997,16 @@ F: net/core/sock_map.c | |
F: net/ipv4/tcp_bpf.c | ||
F: net/ipv4/udp_bpf.c | ||
|
||
LANDLOCK SECURITY MODULE | ||
M: Mickaël Salaün <[email protected]> | ||
L: [email protected] | ||
S: Supported | ||
W: https://landlock.io | ||
T: git https://github.com/landlock-lsm/linux.git | ||
F: security/landlock/ | ||
K: landlock | ||
K: LANDLOCK | ||
|
||
LANTIQ / INTEL Ethernet drivers | ||
M: Hauke Mehrtens <[email protected]> | ||
L: [email protected] | ||
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,21 @@ | ||
# SPDX-License-Identifier: GPL-2.0-only | ||
|
||
config SECURITY_LANDLOCK | ||
bool "Landlock support" | ||
depends on SECURITY | ||
select SECURITY_PATH | ||
help | ||
Landlock is a sandboxing mechanism that enables processes to restrict | ||
themselves (and their future children) by gradually enforcing | ||
tailored access control policies. A Landlock security policy is a | ||
set of access rights (e.g. open a file in read-only, make a | ||
directory, etc.) tied to a file hierarchy. Such policy can be | ||
configured and enforced by any processes for themselves using the | ||
dedicated system calls: landlock_create_ruleset(), | ||
landlock_add_rule(), and landlock_restrict_self(). | ||
|
||
See Documentation/userspace-api/landlock.rst for further information. | ||
|
||
If you are unsure how to answer this question, answer N. Otherwise, | ||
you should also prepend "landlock," to the content of CONFIG_LSM to | ||
enable Landlock at boot time. |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,3 @@ | ||
obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o | ||
|
||
landlock-y := object.o |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,67 @@ | ||
// SPDX-License-Identifier: GPL-2.0-only | ||
/* | ||
* Landlock LSM - Object management | ||
* | ||
* Copyright © 2016-2020 Mickaël Salaün <[email protected]> | ||
* Copyright © 2018-2020 ANSSI | ||
*/ | ||
|
||
#include <linux/bug.h> | ||
#include <linux/compiler_types.h> | ||
#include <linux/err.h> | ||
#include <linux/kernel.h> | ||
#include <linux/rcupdate.h> | ||
#include <linux/refcount.h> | ||
#include <linux/slab.h> | ||
#include <linux/spinlock.h> | ||
|
||
#include "object.h" | ||
|
||
struct landlock_object *landlock_create_object( | ||
const struct landlock_object_underops *const underops, | ||
void *const underobj) | ||
{ | ||
struct landlock_object *new_object; | ||
|
||
if (WARN_ON_ONCE(!underops || !underobj)) | ||
return ERR_PTR(-ENOENT); | ||
new_object = kzalloc(sizeof(*new_object), GFP_KERNEL_ACCOUNT); | ||
if (!new_object) | ||
return ERR_PTR(-ENOMEM); | ||
refcount_set(&new_object->usage, 1); | ||
spin_lock_init(&new_object->lock); | ||
new_object->underops = underops; | ||
new_object->underobj = underobj; | ||
return new_object; | ||
} | ||
|
||
/* | ||
* The caller must own the object (i.e. thanks to object->usage) to safely put | ||
* it. | ||
*/ | ||
void landlock_put_object(struct landlock_object *const object) | ||
{ | ||
/* | ||
* The call to @object->underops->release(object) might sleep, e.g. | ||
* because of iput(). | ||
*/ | ||
might_sleep(); | ||
if (!object) | ||
return; | ||
|
||
/* | ||
* If the @object's refcount cannot drop to zero, we can just decrement | ||
* the refcount without holding a lock. Otherwise, the decrement must | ||
* happen under @object->lock for synchronization with things like | ||
* get_inode_object(). | ||
*/ | ||
if (refcount_dec_and_lock(&object->usage, &object->lock)) { | ||
__acquire(&object->lock); | ||
/* | ||
* With @object->lock initially held, remove the reference from | ||
* @object->underobj to @object (if it still exists). | ||
*/ | ||
object->underops->release(object); | ||
kfree_rcu(object, rcu_free); | ||
} | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,91 @@ | ||
/* SPDX-License-Identifier: GPL-2.0-only */ | ||
/* | ||
* Landlock LSM - Object management | ||
* | ||
* Copyright © 2016-2020 Mickaël Salaün <[email protected]> | ||
* Copyright © 2018-2020 ANSSI | ||
*/ | ||
|
||
#ifndef _SECURITY_LANDLOCK_OBJECT_H | ||
#define _SECURITY_LANDLOCK_OBJECT_H | ||
|
||
#include <linux/compiler_types.h> | ||
#include <linux/refcount.h> | ||
#include <linux/spinlock.h> | ||
|
||
struct landlock_object; | ||
|
||
/** | ||
* struct landlock_object_underops - Operations on an underlying object | ||
*/ | ||
struct landlock_object_underops { | ||
/** | ||
* @release: Releases the underlying object (e.g. iput() for an inode). | ||
*/ | ||
void (*release)(struct landlock_object *const object) | ||
__releases(object->lock); | ||
}; | ||
|
||
/** | ||
* struct landlock_object - Security blob tied to a kernel object | ||
* | ||
* The goal of this structure is to enable to tie a set of ephemeral access | ||
* rights (pertaining to different domains) to a kernel object (e.g an inode) | ||
* in a safe way. This implies to handle concurrent use and modification. | ||
* | ||
* The lifetime of a &struct landlock_object depends on the rules referring to | ||
* it. | ||
*/ | ||
struct landlock_object { | ||
/** | ||
* @usage: This counter is used to tie an object to the rules matching | ||
* it or to keep it alive while adding a new rule. If this counter | ||
* reaches zero, this struct must not be modified, but this counter can | ||
* still be read from within an RCU read-side critical section. When | ||
* adding a new rule to an object with a usage counter of zero, we must | ||
* wait until the pointer to this object is set to NULL (or recycled). | ||
*/ | ||
refcount_t usage; | ||
/** | ||
* @lock: Protects against concurrent modifications. This lock must be | ||
* held from the time @usage drops to zero until any weak references | ||
* from @underobj to this object have been cleaned up. | ||
* | ||
* Lock ordering: inode->i_lock nests inside this. | ||
*/ | ||
spinlock_t lock; | ||
/** | ||
* @underobj: Used when cleaning up an object and to mark an object as | ||
* tied to its underlying kernel structure. This pointer is protected | ||
* by @lock. Cf. landlock_release_inodes() and release_inode(). | ||
*/ | ||
void *underobj; | ||
union { | ||
/** | ||
* @rcu_free: Enables lockless use of @usage, @lock and | ||
* @underobj from within an RCU read-side critical section. | ||
* @rcu_free and @underops are only used by | ||
* landlock_put_object(). | ||
*/ | ||
struct rcu_head rcu_free; | ||
/** | ||
* @underops: Enables landlock_put_object() to release the | ||
* underlying object (e.g. inode). | ||
*/ | ||
const struct landlock_object_underops *underops; | ||
}; | ||
}; | ||
|
||
struct landlock_object *landlock_create_object( | ||
const struct landlock_object_underops *const underops, | ||
void *const underobj); | ||
|
||
void landlock_put_object(struct landlock_object *const object); | ||
|
||
static inline void landlock_get_object(struct landlock_object *const object) | ||
{ | ||
if (object) | ||
refcount_inc(&object->usage); | ||
} | ||
|
||
#endif /* _SECURITY_LANDLOCK_OBJECT_H */ |