Landlock LSM: Toward unprivileged sandboxing
Subsystems (21)
Mickaël Salaün
maintainerv8 cover Landlock LSM: Toward unprivileged sandboxing
Hi,
This eight series is a major revamp of the Landlock design compared to the previous series [1]. This enables more flexibility and granularity of access control with file paths. It is now possible to enforce an access control according to a file hierarchy. Landlock uses the concept of inode and path to identify such hierarchy. In a way, it brings tools to program what is a file hierarchy.
There is now three types of Landlock hooks: FS_WALK, FS_PICK and FS_GET. Each of them accepts a dedicated eBPF program, called a Landlock program. They can be chained to enforce a full access control according to a list of directories or files. The set of actions on a file is well defined (e.g. read, write, ioctl, append, lock, mount...) taking inspiration from the major Linux LSMs and some other access-controls like Capsicum. These program types are designed to be cache-friendly, which give room for optimizations in the future.
The documentation patch contains some kernel documentation and explanations on how to use Landlock. The compiled documentation and a talk I gave at FOSDEM can be found here: https://landlock.io
This patch series can be found in the branch landlock-v8 in this repo:
https://github.com/landlock-lsm/linux
There is still some minor issues with this patch series but it should demonstrate how powerful this design may be. One of these issues is that it is not a stackable LSM anymore, but the infrastructure management of security blobs should allow to stack it with other LSM [4].
This is the first step of the roadmap discussed at LPC [2]. While the intended final goal is to allow unprivileged users to use Landlock, this series allows only a process with global CAP_SYS_ADMIN to load and enforce a rule. This may help to get feedback and avoid unexpected behaviors.
This series can be applied on top of bpf-next, commit 7d72637eb39f ("Merge branch 'x86-jit'"). This can be tested with CONFIG_SECCOMP_FILTER and CONFIG_SECURITY_LANDLOCK. I would really appreciate constructive comments on the design and the code.
# Landlock LSM
The goal of this new Linux Security Module (LSM) called Landlock is to allow any process, including unprivileged ones, to create powerful security sandboxes comparable to XNU Sandbox or OpenBSD Pledge. This kind of sandbox is expected to help mitigate the security impact of bugs or unexpected/malicious behaviors in user-space applications.
The approach taken is to add the minimum amount of code while still allowing the user-space application to create quite complex access rules. A dedicated security policy language such as the one used by SELinux, AppArmor and other major LSMs involves a lot of code and is usually permitted to only a trusted user (i.e. root). On the contrary, eBPF programs already exist and are designed to be safely loaded by unprivileged user-space.
This design does not seem too intrusive but is flexible enough to allow a powerful sandbox mechanism accessible by any process on Linux. The use of seccomp and Landlock is more suitable with the help of a user-space library (e.g. libseccomp) that could help to specify a high-level language to express a security policy instead of raw eBPF programs. Moreover, thanks to the LLVM front-end, it is quite easy to write an eBPF program with a subset of the C language.
# Frequently asked questions
## Why is seccomp-bpf not enough?
A seccomp filter can access only raw syscall arguments (i.e. the register values) which means that it is not possible to filter according to the value pointed to by an argument, such as a file pathname. As an embryonic Landlock version demonstrated, filtering at the syscall level is complicated (e.g. need to take care of race conditions). This is mainly because the access control checkpoints of the kernel are not at this high-level but more underneath, at the LSM-hook level. The LSM hooks are designed to handle this kind of checks. Landlock abstracts this approach to leverage the ability of unprivileged users to limit themselves.
Cf. section "What it isn't?" in Documentation/prctl/seccomp_filter.txt
## Why use the seccomp(2) syscall?
Landlock use the same semantic as seccomp to apply access rule restrictions. It add a new layer of security for the current process which is inherited by its children. It makes sense to use an unique access-restricting syscall (that should be allowed by seccomp filters) which can only drop privileges. Moreover, a Landlock rule could come from outside a process (e.g. passed through a UNIX socket). It is then useful to differentiate the creation/load of Landlock eBPF programs via bpf(2), from rule enforcement via seccomp(2).
## Why a new LSM? Are SELinux, AppArmor, Smack and Tomoyo not good
enough?
The current access control LSMs are fine for their purpose which is to give the *root* the ability to enforce a security policy for the *system*. What is missing is a way to enforce a security policy for any application by its developer and *unprivileged user* as seccomp can do for raw syscall filtering.
Differences from other (access control) LSMs:
* not only dedicated to administrators (i.e. no_new_priv);
* limited kernel attack surface (e.g. policy parsing);
* constrained policy rules (no DoS: deterministic execution time);
* do not leak more information than the loader process can legitimately have access to (minimize metadata inference).
# Changes since v7
* major revamp of the file system enforcement:
* new eBPF map dedicated to tie an inode with an arbitrary 64-bits value, which can be used to tag files
* three new Landlock hooks: FS_WALK, FS_PICK and FS_GET
* add the ability to chain Landlock programs
* add a new eBPF map type to compare inodes
* don't use macros anymore
* replace subtype fields:
* triggers: fine-grained bitfiel of actions on which a Landlock program may be called (if it comes from a sandbox process)
* previous: a parent chained program
* upstreamed patches:
* commit 369130b63178 ("selftests: Enhance kselftest_harness.h to print which assert failed")
# Changes since v6
* upstreamed patches:
* commit 752ba56fb130 ("bpf: Extend check_uarg_tail_zero() checks")
* commit 0b40808a1084 ("selftests: Make test_harness.h more generally available") and related ones
* commit 3bb857e47e49 ("LSM: Enable multiple calls to security_add_hooks() for the same LSM")
* simplify the landlock_context (remove syscall_* fields) and add three FS sub-events: IOCTL, LOCK, FCNTL
* minimize the number of callable BPF functions from a Landlock rule
* do not split put_seccomp_filter() with put_seccomp()
* rename Landlock version to Landlock ABI
* miscellaneous fixes
* rebase on net-next
# Changes since v5
* eBPF program subtype:
* use a prog_subtype pointer instead of inlining it into bpf_attr
* enable a future-proof behavior (reject unhandled data/size)
* add tests
* use a simple rule hierarchy (similar to seccomp-bpf)
* add a ptrace scope protection
* add more tests
* add more documentation
* rename some files
* miscellaneous fixes
* rebase on net-next
# Changes since v4
* upstreamed patches:
* commit d498f8719a09 ("bpf: Rebuild bpf.o for any dependency update")
* commit a734fb5d6006 ("samples/bpf: Reset global variables") and related ones
* commit f4874d01beba ("bpf: Use bpf_create_map() from the library") and related ones
* commit d02d8986a768 ("bpf: Always test unprivileged programs")
* commit 640eb7e7b524 ("fs: Constify path_is_under()'s arguments")
* commit 535e7b4b5ef2 ("bpf: Use u64_to_user_ptr()")
* revamp Landlock to not expose an LSM hook interface but wrap and abstract them with Landlock events (currently one for all filesystem related operations: LANDLOCK_SUBTYPE_EVENT_FS)
* wrap all filesystem kernel objects through the same FS handle (struct landlock_handle_fs): struct file, struct inode, struct path and struct dentry
* a rule don't return an errno code but only a boolean to allow or deny an access request
* handle all filesystem related LSM hooks
* add some tests and a sample:
* BPF context tests
* Landlock sandboxing tests and sample
* write Landlock rules in C and compile them with LLVM
* change field names of eBPF program subtype
* remove arraymap of handles for now (will be replaced with a revamped map)
* remove cgroup handling for now
* add user and kernel documentation
* rebase on net-next
# Changes since v3
* upstreamed patch:
* commit 1955351da41c ("bpf: Set register type according to
is_valid_access()")
* use abstract LSM hook arguments with custom types (e.g. *_LANDLOCK_ARG_FS for struct file, struct inode and struct path)
* add more LSM hooks to support full filesystem access control
* improve the sandbox example
* fix races and RCU issues:
* eBPF program execution and eBPF helpers
* revamp the arraymap of handles to cleanly deal with update/delete
* eBPF program subtype for Landlock:
* remove the "origin" field
* add an "option" field
* rebase onto Daniel Mack's patches v7 [3]
* remove merged commit 1955351da41c ("bpf: Set register type according to is_valid_access()")
* fix spelling mistakes
* cleanup some type and variable names
* split patches
* for now, remove cgroup delegation handling for unprivileged user
* remove extra access check for cgroup_get_from_fd()
* remove unused example code dealing with skb
* remove seccomp-bpf link:
* no more seccomp cookie
* for now, it is no more possible to check the current syscall properties
# Changes since v2
* revamp cgroup handling:
* use Daniel Mack's patches "Add eBPF hooks for cgroups" v5
* remove bpf_landlock_cmp_cgroup_beneath()
* make BPF_PROG_ATTACH usable with delegated cgroups
* add a new CGRP_NO_NEW_PRIVS flag for safe cgroups
* handle Landlock sandboxing for cgroups hierarchy
* allow unprivileged processes to attach Landlock eBPF program to cgroups
* add subtype to eBPF programs:
* replace Landlock hook identification by custom eBPF program types with a dedicated subtype field
* manage fine-grained privileged Landlock programs
* register Landlock programs for dedicated trigger origins (e.g. syscall, return from seccomp filter and/or interruption)
* performance and memory optimizations: use an array to access Landlock hooks directly but do not duplicated it for each thread (seccomp-based)
* allow running Landlock programs without seccomp filter
* fix seccomp-related issues
* remove extra errno bounding check for Landlock programs
* add some examples for optional eBPF functions or context access (network related) according to security checks to allow more features for privileged programs (e.g. Checmate)
# Changes since v1
* focus on the LSM hooks, not the syscalls:
* much more simple implementation
* does not need audit cache tricks to avoid race conditions
* more simple to use and more generic because using the LSM hook abstraction directly
* more efficient because only checking in LSM hooks
* architecture agnostic
* switch from cBPF to eBPF:
* new eBPF program types dedicated to Landlock
* custom functions used by the eBPF program
* gain some new features (e.g. 10 registers, can load values of different size, LLVM translator) but only a few functions allowed and a dedicated map type
* new context: LSM hook ID, cookie and LSM hook arguments
* need to set the sysctl kernel.unprivileged_bpf_disable to 0 (default value) to be able to load hook filters as unprivileged users
* smaller and simpler:
* no more checker groups but dedicated arraymap of handles
* simpler userland structs thanks to eBPF functions
* distinctive name: Landlock
[1] https://lkml.kernel.org/r/[email protected]
[2] https://lkml.kernel.org/r/[email protected]
[3] https://lkml.kernel.org/r/[email protected]
[4] https://lwn.net/Articles/741963/
Regards,
Mickaël Salaün (11):
fs,security: Add a security blob to nameidata fs,security: Add a new file access type: MAY_CHROOT
bpf: Add eBPF program subtype and is_valid_subtype() verifier bpf,landlock: Define an eBPF program type for Landlock hooks seccomp,landlock: Enforce Landlock programs per process hierarchy bpf,landlock: Add a new map type: inode
landlock: Handle filesystem access control
landlock: Add ptrace restrictions
bpf: Add a Landlock sandbox example
bpf,landlock: Add tests for Landlock
landlock: Add user and kernel documentation for Landlock
Documentation/security/index.rst | 1 + Documentation/security/landlock/index.rst | 19 + Documentation/security/landlock/kernel.rst | 100 +++ Documentation/security/landlock/user.rst | 206 +++++ MAINTAINERS | 13 + fs/namei.c | 39 + fs/open.c | 3 +- include/linux/bpf.h | 35 +- include/linux/bpf_types.h | 6 + include/linux/fs.h | 1 + include/linux/landlock.h | 61 ++ include/linux/lsm_hooks.h | 12 + include/linux/namei.h | 14 +- include/linux/seccomp.h | 5 + include/linux/security.h | 7 + include/uapi/linux/bpf.h | 34 +- include/uapi/linux/landlock.h | 155 ++++ include/uapi/linux/seccomp.h | 1 + kernel/bpf/Makefile | 3 + kernel/bpf/cgroup.c | 6 +- kernel/bpf/core.c | 6 +- kernel/bpf/helpers.c | 38 + kernel/bpf/inodemap.c | 318 ++++++++ kernel/bpf/syscall.c | 62 +- kernel/bpf/verifier.c | 44 +- kernel/fork.c | 8 +- kernel/seccomp.c | 4 + kernel/trace/bpf_trace.c | 15 +- net/core/filter.c | 76 +- samples/bpf/Makefile | 4 + samples/bpf/bpf_load.c | 85 +- samples/bpf/bpf_load.h | 7 + samples/bpf/cookie_uid_helper_example.c | 2 +- samples/bpf/fds_example.c | 2 +- samples/bpf/landlock1.h | 14 + samples/bpf/landlock1_kern.c | 171 ++++ samples/bpf/landlock1_user.c | 164 ++++ samples/bpf/sock_example.c | 3 +- samples/bpf/test_cgrp2_attach.c | 2 +- samples/bpf/test_cgrp2_attach2.c | 4 +- samples/bpf/test_cgrp2_sock.c | 2 +- security/Kconfig | 1 + security/Makefile | 2 + security/landlock/Kconfig | 18 + security/landlock/Makefile | 6 + security/landlock/chain.c | 39 + security/landlock/chain.h | 35 + security/landlock/common.h | 94 +++ security/landlock/enforce.c | 386 +++++++++ security/landlock/enforce.h | 21 + security/landlock/enforce_seccomp.c | 112 +++ security/landlock/hooks.c | 121 +++ security/landlock/hooks.h | 35 + security/landlock/hooks_cred.c | 52 ++ security/landlock/hooks_cred.h | 1 + security/landlock/hooks_fs.c | 1021 ++++++++++++++++++++++++ security/landlock/hooks_fs.h | 60 ++ security/landlock/hooks_ptrace.c | 124 +++ security/landlock/hooks_ptrace.h | 11 + security/landlock/init.c | 238 ++++++ security/landlock/tag.c | 373 +++++++++ security/landlock/tag.h | 36 + security/landlock/tag_fs.c | 59 ++ security/landlock/tag_fs.h | 26 + security/landlock/task.c | 34 + security/landlock/task.h | 29 + security/security.c | 19 +- tools/include/uapi/linux/bpf.h | 34 +- tools/include/uapi/linux/landlock.h | 155 ++++ tools/lib/bpf/bpf.c | 15 +- tools/lib/bpf/bpf.h | 8 +- tools/lib/bpf/libbpf.c | 5 +- tools/perf/tests/bpf.c | 2 +- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/bpf/bpf_helpers.h | 7 + tools/testing/selftests/bpf/test_align.c | 2 +- tools/testing/selftests/bpf/test_tag.c | 2 +- tools/testing/selftests/bpf/test_verifier.c | 102 ++- tools/testing/selftests/landlock/.gitignore | 5 + tools/testing/selftests/landlock/Makefile | 35 + tools/testing/selftests/landlock/test.h | 31 + tools/testing/selftests/landlock/test_base.c | 27 + tools/testing/selftests/landlock/test_chain.c | 249 ++++++ tools/testing/selftests/landlock/test_fs.c | 492 ++++++++++++ tools/testing/selftests/landlock/test_ptrace.c | 158 ++++ 85 files changed, 5960 insertions(+), 75 deletions(-) create mode 100644 Documentation/security/landlock/index.rst create mode 100644 Documentation/security/landlock/kernel.rst create mode 100644 Documentation/security/landlock/user.rst create mode 100644 include/linux/landlock.h create mode 100644 include/uapi/linux/landlock.h create mode 100644 kernel/bpf/inodemap.c create mode 100644 samples/bpf/landlock1.h create mode 100644 samples/bpf/landlock1_kern.c create mode 100644 samples/bpf/landlock1_user.c create mode 100644 security/landlock/Kconfig create mode 100644 security/landlock/Makefile create mode 100644 security/landlock/chain.c create mode 100644 security/landlock/chain.h create mode 100644 security/landlock/common.h create mode 100644 security/landlock/enforce.c create mode 100644 security/landlock/enforce.h create mode 100644 security/landlock/enforce_seccomp.c create mode 100644 security/landlock/hooks.c create mode 100644 security/landlock/hooks.h create mode 100644 security/landlock/hooks_cred.c create mode 100644 security/landlock/hooks_cred.h create mode 100644 security/landlock/hooks_fs.c create mode 100644 security/landlock/hooks_fs.h create mode 100644 security/landlock/hooks_ptrace.c create mode 100644 security/landlock/hooks_ptrace.h create mode 100644 security/landlock/init.c create mode 100644 security/landlock/tag.c create mode 100644 security/landlock/tag.h create mode 100644 security/landlock/tag_fs.c create mode 100644 security/landlock/tag_fs.h create mode 100644 security/landlock/task.c create mode 100644 security/landlock/task.h create mode 100644 tools/include/uapi/linux/landlock.h create mode 100644 tools/testing/selftests/landlock/.gitignore create mode 100644 tools/testing/selftests/landlock/Makefile create mode 100644 tools/testing/selftests/landlock/test.h create mode 100644 tools/testing/selftests/landlock/test_base.c create mode 100644 tools/testing/selftests/landlock/test_chain.c create mode 100644 tools/testing/selftests/landlock/test_fs.c create mode 100644 tools/testing/selftests/landlock/test_ptrace.c
Signature · 1 line
2.16.2
Mickaël Salaün
maintainerPATCH v8 1/11 fs,security: Add a security blob to nameidata
The function current_nameidata_security(struct inode *) can be used to retrieve a blob's pointer address tied to the inode being walk through. This enable to follow a path lookup and know where an inode access come from. This is needed for the Landlock LSM to be able to restrict access to file path.
The LSM hook nameidata_free_security(struct inode *) is called before freeing the associated nameidata.
--- fs/namei.c | 39 +++++++++++++++++++++++++++++++++++++++ include/linux/lsm_hooks.h | 7 +++++++ include/linux/namei.h | 14 +++++++++++++- include/linux/security.h | 7 +++++++ security/security.c | 7 +++++++ 5 files changed, 73 insertions(+), 1 deletion(-)
fs/namei.c +39 -0
@@ -505,6 +505,9 @@ struct nameidata {struct inode *link_inode;unsigned root_seq;int dfd; +#ifdef CONFIG_SECURITY +struct nameidata_lookup lookup; +#endif } __randomize_layout;static void set_nameidata (struct nameidata *p,int dfd,struct filename *name)
@@ -515,6 +518,9 @@ static void set_nameidata(struct nameidata *p, int dfd, struct filename *name) p->name = name; p->total_link_count = old ? old->total_link_count :0 ; p->saved = old; +#ifdef CONFIG_SECURITY + p->lookup.security =NULL ; +#endif current->nameidata = p; }
@@ -522,6 +528,7 @@ static void restore_nameidata(void) {struct nameidata *now = current->nameidata, *old = now->saved; +security_nameidata_put_lookup (&now->lookup, now->inode); current->nameidata = old;if (old) old->total_link_count = now->total_link_count;
@@ -549,6 +556,27 @@ static int __nd_alloc_stack(struct nameidata *nd)return 0 ; } +#ifdef CONFIG_SECURITY +/** +* current_nameidata_lookup - get the state of the current path walk +* +* @inode: inode associated to the path walk +* +* Used by LSM modules for access restriction based on path walk. The LSM is in +* charge of the lookup->security blob allocation and management. The hook +* security_nameidata_put_lookup() will be called after the path walk end. +* +* Return ERR_PTR(-ENOENT) if there is no match. +*/ +struct nameidata_lookup *current_nameidata_lookup (const struct inode *inode) +{ +if (!current->nameidata || current->nameidata->inode != inode) +return ERR_PTR (-ENOENT ); +return ¤t->nameidata->lookup; +} +EXPORT_SYMBOL (current_nameidata_lookup); +#endif +/** * path_connected - Verify that a path->dentry is below path->mnt.mnt_root * @path: nameidate to verify
@@ -2009,6 +2037,13 @@ static inline u64 hash_name(const void *salt, const char *name)#endif +static inline void refresh_lookup (struct nameidata *nd) +{ +#ifdef CONFIG_SECURITY + nd->lookup.type = nd->last_type; +#endif +} +/* * Name resolution. * This is the basic name resolution function, turning a pathname into
@@ -2025,6 +2060,8 @@ static int link_path_walk(const char *name, struct nameidata *nd) name++;if (!*name)return 0 ; +/* be ready for may_lookup() */ +refresh_lookup (nd);/* At this point we know we have a real path component. */ for (;;) {
@@ -2064,6 +2101,8 @@ static int link_path_walk(const char *name, struct nameidata *nd) nd->last.hash_len = hash_len; nd->last.name = name; nd->last_type = type; +/* be ready for the next security_inode_permission() */ +refresh_lookup (nd); name +=hashlen_len (hash_len);if (!*name)
include/linux/lsm_hooks.h +7 -0
@@ -428,6 +428,10 @@* security module does not know about attribute or a negative error code * to abort the copy up. Note that the caller is responsible for reading * and writing the xattrs as this hook is merely a filter. +* @nameidata_put_lookup: +* Deallocate and clear the current's nameidata->lookup.security field. +* @lookup->security contains the security structure to be freed. +* @inode is the last associated inode to the path walk * * Security hooks for file operations *
@@ -1514,6 +1518,8 @@ union security_list_options {void (*inode_getsecid)(struct inode *inode,u32 *secid);int (*inode_copy_up)(struct dentry *src,struct cred **new);int (*inode_copy_up_xattr)(const char *name); +void (*nameidata_put_lookup)(struct nameidata_lookup *lookup, +struct inode *inode);int (*file_permission)(struct file *file,int mask);int (*file_alloc_security)(struct file *file);
@@ -1805,6 +1811,7 @@ struct security_hook_heads {struct list_head inode_getsecid;struct list_head inode_copy_up;struct list_head inode_copy_up_xattr; +struct list_head nameidata_put_lookup;struct list_head file_permission;struct list_head file_alloc_security;struct list_head file_free_security;
include/linux/namei.h +13 -1
@@ -14,7 +14,19 @@ enum { MAX_NESTED_LINKS = 8 };/* * Type of the last component on LOOKUP_PARENT */ -enum {LAST_NORM ,LAST_ROOT ,LAST_DOT ,LAST_DOTDOT ,LAST_BIND }; +enum namei_type {LAST_NORM ,LAST_ROOT ,LAST_DOT ,LAST_DOTDOT ,LAST_BIND }; + +#ifdef CONFIG_SECURITY +struct nameidata_lookup { +void *security; +enum namei_type type; +}; + +struct inode ; + +extern struct nameidata_lookup *current_nameidata_lookup ( +const struct inode *inode); +#endif /* * The bitmask for a lookup event:
include/linux/security.h +7 -0
@@ -31,6 +31,7 @@#include <linux/string.h> #include <linux/mm.h> #include <linux/fs.h> +#include <linux/namei.h> struct linux_binprm ;struct cred ;
@@ -302,6 +303,8 @@ int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffervoid security_inode_getsecid (struct inode *inode,u32 *secid);int security_inode_copy_up (struct dentry *src,struct cred **new);int security_inode_copy_up_xattr (const char *name); +void security_nameidata_put_lookup (struct nameidata_lookup *lookup, +struct inode *inode);int security_file_permission (struct file *file,int mask);int security_file_alloc (struct file *file);void security_file_free (struct file *file);
@@ -808,6 +811,10 @@ static inline int security_inode_copy_up_xattr(const char *name)return -EOPNOTSUPP ; } +static inline void security_nameidata_put_lookup ( +struct nameidata_lookup *lookup,struct inode *inode) +{ } +static inline int security_file_permission (struct file *file,int mask) {return 0 ;
security/security.c +7 -0
@@ -857,6 +857,13 @@ int security_inode_copy_up_xattr(const char *name) }EXPORT_SYMBOL (security_inode_copy_up_xattr); +void security_nameidata_put_lookup (struct nameidata_lookup *lookup, +struct inode *inode) +{ +call_void_hook (nameidata_put_lookup, lookup, inode); +} +EXPORT_SYMBOL (security_nameidata_put_lookup); +int security_file_permission (struct file *file,int mask) {int ret;
Signature · 1 line
2.16.2
Al Viro
maintainerRe: [PATCH bpf-next v8 01/11] fs,security: Add a security blob to nameidata
Quoted 8 lines · Mickaël Salaün
The function
current_nameidata_security(struct inode *)can be used to retrieve a blob's pointer address tied to the inode being walk through. This enable to follow a path lookup and know where an inode access come from. This is needed for the Landlock LSM to be able to restrict access to file path.The LSM hook
nameidata_free_security(struct inode *)is called before freeing the associated nameidata.
NAK. Not without well-defined semantics and "some Linux S&M uses that for something, don't ask what" does not count.
Al Viro
maintainerRe: [PATCH bpf-next v8 01/11] fs,security: Add a security blob to nameidata
Quoted 7 lines · Al Viro
Quoted 6 lines · Mickaël Salaün
The function
current_nameidata_security(struct inode *)can be used to retrieve a blob's pointer address tied to the inode being walk through. This enable to follow a path lookup and know where an inode access come from. This is needed for the Landlock LSM to be able to restrict access to file path.
Quoted 5 lines
Quoted 2 lines
The LSM hook
nameidata_free_security(struct inode *)is called before freeing the associated nameidata.NAK. Not without well-defined semantics and "some Linux S&M uses that for something, don't ask what" does not count.
Incidentally, pathwalk mechanics is subject to change at zero notice, so if you want something, you'd better
* have explicitly defined semantics
* explain what it is - on fsdevel
* not have it hidden behind the layers of opaque LSM dreck, pardon
the redundance.
Again, pathwalk internals have changed in the past and may bloody well change again in the future. There's a damn good reason why struct nameidata is _not_ visible outside of fs/namei.c, and quietly relying upon any implementation details is no-go.
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 01/11] fs,security: Add a security blob to nameidata
Quoted 21 lines · Al Viro
Quoted 7 lines · Al Viro
Quoted 6 lines · Mickaël Salaün
The function
current_nameidata_security(struct inode *)can be used to retrieve a blob's pointer address tied to the inode being walk through. This enable to follow a path lookup and know where an inode access come from. This is needed for the Landlock LSM to be able to restrict access to file path.Quoted 5 lines
Quoted 2 lines
The LSM hook
nameidata_free_security(struct inode *)is called before freeing the associated nameidata.NAK. Not without well-defined semantics and "some Linux S&M uses that for something, don't ask what" does not count.
Incidentally, pathwalk mechanics is subject to change at zero notice, so if you want something, you'd better
* have explicitly defined semantics
* explain what it is - on fsdevel
* not have it hidden behind the layers of opaque LSM dreck, pardon
the redundance.
Quoted 5 lines
Again, pathwalk internals have changed in the past and may bloody well change again in the future. There's a damn good reason why struct nameidata is _not_ visible outside of
fs/namei.c, and quietly relying upon any implementation details is no-go.
I thought this whole patch series would go to linux-fsdevel but only this patch did. I'll CCed fsdevel for the next round. Meanwhile, the cover letter is here: https://lkml.org/lkml/2018/2/26/1214
The code using current_nameidata_lookup(inode) is in the patch 07/11:
https://lkml.org/lkml/2018/2/26/1206
To sum up, I don't know any way to identify if a directory (execute) access was directly requested by a process or inferred by the kernel because of a path walk. This was not needed until now because the other access control systems (either the DAC or access controls enforced by inode-based LSM, i.e. SELinux and Smack) do not care about the file hierarchy. Path-based access controls (i.e. AppArmor and Tomoyo) directly use the notion of path to define a security policy (in the kernel, not only in the user space configuration). Landlock can't rely on xattrs (because of composed and unprivileged access control). Because we can't know for sure from which path an inode come from (if any), path-based LSM hooks do not help for some file system checks (e.g. inode_permission). With Landlock, I try to find a way to identify a set of inodes, from the user space point of view, which is most of the time related to file hierarchies.
I needed a way to "follow" a path walk, with the minimum amount of code, and if possible without touching the fs/namei.c . I saw that the pathwalk mechanism has evolved over time. With this patch, I tried to make a kernel object (nameidata) usable in some way by LSM, but only through an inode (current_nameidata_lookup(inode)). The "only" guarantee of this function should be to identify if an inode is tied to a path walk. This enable to follow a path walk and know why an inode access is requested.
I get your concern about the "instability" of the path walk mechanism. However, I though that a path resolution should not change from the user space point of view, like other Linux ABI. Anyway, all the current inode-based access controls, including DAC, rely on this path walks mechanism. This patch does not expose anything to user space, but only through the API of Landlock, which is currently relying on path walk resolutions, already visible to user space. Did I miss something? Do you have another suggestion to tie an inode to a path walk?
Thanks,
Mickaël
kbuild test robot
build botRe: [PATCH bpf-next v8 01/11] fs,security: Add a security blob to nameidata
In reply to Mickaël SalaünThank you for the patch! Perhaps something to improve:
Hi Mickaël,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on bpf-next/master]
url: https://github.com/0day-ci/linux/commits/Micka-l-Sala-n/Landlock-LSM-Toward-unprivileged-sandboxing/20180228-233659 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master config: x86_64-randconfig-x017-201808 (attached as .config) compiler: gcc-7 (Debian 7.3.0-1) 7.3.0 reproduce: # save the attached .config to linux build tree make ARCH=x86_64
All warnings (new ones prefixed by >>):
In file included from fs//quota/dquot.c:74:0:
>> include/linux/security.h:815:10: warning: 'struct nameidata_lookup' declared inside parameter list will not be visible outside of this definition or declaration
struct nameidata_lookup *lookup, struct inode *inode)
^~~~~~~~~~~~~~~~
vim +815 include/linux/security.h
813
814 static inline void security_nameidata_put_lookup(
> 815 struct nameidata_lookup *lookup, struct inode *inode)
816 { }
817
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
kbuild test robot
build botRe: [PATCH bpf-next v8 01/11] fs,security: Add a security blob to nameidata
In reply to Mickaël SalaünThank you for the patch! Perhaps something to improve:
Hi Mickaël,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on bpf-next/master]
url: https://github.com/0day-ci/linux/commits/Micka-l-Sala-n/Landlock-LSM-Toward-unprivileged-sandboxing/20180228-233659 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master config: i386-randconfig-a1-201808 (attached as .config) compiler: gcc-4.9 (Debian 4.9.4-2) 4.9.4 reproduce: # save the attached .config to linux build tree make ARCH=i386
All warnings (new ones prefixed by >>):
In file included from init/main.c:37:0:
>> include/linux/security.h:815:43: warning: 'struct nameidata_lookup' declared inside parameter list
struct nameidata_lookup *lookup, struct inode *inode)
^
>> include/linux/security.h:815:43: warning: its scope is only this definition or declaration, which is probably not what you want
--
In file included from fs/namei.c:27:0:
>> include/linux/security.h:815:43: warning: 'struct nameidata_lookup' declared inside parameter list
struct nameidata_lookup *lookup, struct inode *inode)
^
>> include/linux/security.h:815:43: warning: its scope is only this definition or declaration, which is probably not what you want
fs/namei.c: In function 'restore_nameidata':
fs/namei.c:531:36: error: 'struct nameidata' has no member named 'lookup'
security_nameidata_put_lookup(&now->lookup, now->inode);
^
--
In file included from include/linux/lsm_hooks.h:28:0,
from security/commoncap.c:15:
>> include/linux/security.h:815:43: warning: 'struct nameidata_lookup' declared inside parameter list
struct nameidata_lookup *lookup, struct inode *inode)
^
>> include/linux/security.h:815:43: warning: its scope is only this definition or declaration, which is probably not what you want
In file included from security/commoncap.c:15:0:
>> include/linux/lsm_hooks.h:1522:13: warning: 'struct nameidata_lookup' declared inside parameter list
struct inode *inode);
^vim +815 include/linux/security.h
813
814 static inline void security_nameidata_put_lookup(
> 815 struct nameidata_lookup *lookup, struct inode *inode)
816 { }
817
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
Mickaël Salaün
maintainerPATCH v8 2/11 fs,security: Add a new file access type: MAY_CHROOT
In reply to Mickaël SalaünFor compatibility reason, MAY_CHROOT is always set with MAY_CHDIR. However, this new flag enable to differentiate a chdir form a chroot.
This is needed for the Landlock LSM to be able to evaluate a new root directory.
--- fs/open.c | 3 ++- include/linux/fs.h | 1 + 2 files changed, 3 insertions(+), 1 deletion(-)
fs/open.c +2 -1
@@ -489,7 +489,8 @@ SYSCALL_DEFINE1(chroot, const char __user *, filename)if (error) goto out; - error =inode_permission (path.dentry->d_inode,MAY_EXEC |MAY_CHDIR ); + error =inode_permission (path.dentry->d_inode,MAY_EXEC |MAY_CHDIR | +MAY_CHROOT );if (error) goto dput_and_out;
include/linux/fs.h +1 -0
@@ -90,6 +90,7 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,#define MAY_CHDIR 0x00000040/* called from RCU mode, don't block */ #define MAY_NOT_BLOCK 0x00000080 +#define MAY_CHROOT 0x00000100/* * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
Signature · 1 line
2.16.2
Mickaël Salaün
maintainerPATCH v8 3/11 bpf: Add eBPF program subtype and is_valid_subtype() verifier
In reply to Mickaël SalaünThe goal of the program subtype is to be able to have different static fine-grained verifications for a unique program type.
The struct bpf_verifier_ops gets a new optional function:is_valid_subtype(). This new verifier is called at the beginning of the eBPF program verification to check if the (optional) program subtype is valid.
The struct bpf_prog_ops gets a new optional function: put_extra(). This may be used to put extra data.
For now, only Landlock eBPF programs are using a program subtype (see next commits) but this could be used by other program types in the future.
---
Changes since v7:
* rename LANDLOCK_SUBTYPE_* to LANDLOCK_*
* move subtype in bpf_prog_aux and use only one bit for has_subtype (suggested by Alexei Starovoitov)
* wrap the prog_subtype with a prog_extra to be able to reference kernel pointers:
* add an optional put_extra() function to struct bpf_prog_ops to be able to free the pointed data
* replace all the prog_subtype with prog_extra in the struct bpf_verifier_ops functions
* remove the ABI field (requested by Alexei Starovoitov)
* rename subtype fields
Changes since v6:
* rename Landlock version to ABI to better reflect its purpose
* fix unsigned integer checks
* fix pointer cast
* constify pointers
* rebase
Changes since v5:
* use a prog_subtype pointer and make it future-proof
* add subtype test
* constify bpf_load_program()'s subtype argument
* cleanup subtype initialization
* rebase
Changes since v4:
* replace the "status" field with "version" (more generic)
* replace the "access" field with "ability" (less confusing)
Changes since v3:
* remove the "origin" field
* add an "option" field
* cleanup comments
--- include/linux/bpf.h | 17 ++++++- include/uapi/linux/bpf.h | 11 +++++ kernel/bpf/cgroup.c | 6 ++- kernel/bpf/core.c | 5 +- kernel/bpf/syscall.c | 35 ++++++++++++- kernel/bpf/verifier.c | 19 ++++++-- kernel/trace/bpf_trace.c | 15 ++++-- net/core/filter.c | 76 ++++++++++++++++++----------- samples/bpf/bpf_load.c | 3 +- samples/bpf/cookie_uid_helper_example.c | 2 +- samples/bpf/fds_example.c | 2 +- samples/bpf/sock_example.c | 3 +- samples/bpf/test_cgrp2_attach.c | 2 +- samples/bpf/test_cgrp2_attach2.c | 4 +- samples/bpf/test_cgrp2_sock.c | 2 +- tools/include/uapi/linux/bpf.h | 11 +++++ tools/lib/bpf/bpf.c | 15 ++++-- tools/lib/bpf/bpf.h | 8 +-- tools/lib/bpf/libbpf.c | 5 +- tools/perf/tests/bpf.c | 2 +- tools/testing/selftests/bpf/test_align.c | 2 +- tools/testing/selftests/bpf/test_tag.c | 2 +- tools/testing/selftests/bpf/test_verifier.c | 18 ++++++- 23 files changed, 200 insertions(+), 65 deletions(-)
include/linux/bpf.h +15 -2
@@ -200,26 +200,38 @@ bpf_ctx_record_field_size(struct bpf_insn_access_aux *aux, u32 size) aux->ctx_field_size = size; } +/* specific data per program type */ +struct bpf_prog_extra { +union bpf_prog_subtype subtype; +union { +struct bpf_prog *previous; + } landlock_hook; +}; +struct bpf_prog_ops {int (*test_run)(struct bpf_prog *prog,const union bpf_attr *kattr,union bpf_attr __user *uattr); +void (*put_extra)(struct bpf_prog_extra *prog_extra); };struct bpf_verifier_ops {/* return eBPF function prototype for verification */ -const struct bpf_func_proto *(*get_func_proto)(enum bpf_func_id func_id); +const struct bpf_func_proto *(*get_func_proto)(enum bpf_func_id func_id, +const struct bpf_prog_extra *prog_extra);/* return true if 'size' wide access at offset 'off' within bpf_context * with 'type' (read or write) is allowed */ bool (*is_valid_access)(int off,int size,enum bpf_access_type type, -struct bpf_insn_access_aux *info); +struct bpf_insn_access_aux *info, +const struct bpf_prog_extra *prog_extra);int (*gen_prologue)(struct bpf_insn *insn,bool direct_write,const struct bpf_prog *prog);u32 (*convert_ctx_access)(enum bpf_access_type type,const struct bpf_insn *src,struct bpf_insn *dst,struct bpf_prog *prog,u32 *target_size); +bool (*is_valid_subtype)(struct bpf_prog_extra *prog_extra); };struct bpf_prog_offload_ops {
@@ -264,6 +276,7 @@ struct bpf_prog_aux {struct work_struct work;struct rcu_head rcu; }; +struct bpf_prog_extra *extra; };struct bpf_array {
include/uapi/linux/bpf.h +11 -0
@@ -231,6 +231,15 @@ enum bpf_attach_type {#define BPF_F_RDONLY (1U << 3)#define BPF_F_WRONLY (1U << 4) +union bpf_prog_subtype { +struct { +__u32 type;/* enum landlock_hook_type */ +__aligned_u64 triggers;/* LANDLOCK_TRIGGER_* */ +__aligned_u64 options;/* LANDLOCK_OPTION_* */ +__u32 previous;/* chained program FD */ + } landlock_hook; +} __attribute__((aligned (8 ))); +union bpf_attr {struct {/* anonymous struct used by BPF_MAP_CREATE command */ __u32 map_type;/* one of enum bpf_map_type */
@@ -270,6 +279,8 @@ union bpf_attr {__u32 prog_flags;char prog_name[BPF_OBJ_NAME_LEN ];__u32 prog_ifindex;/* ifindex of netdev to prep for */ +__aligned_u64 prog_subtype;/* bpf_prog_subtype address */ +__u32 prog_subtype_size; };struct {/* anonymous struct used by BPF_OBJ_* commands */
kernel/bpf/cgroup.c +4 -2
@@ -545,7 +545,8 @@ int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor,EXPORT_SYMBOL (__cgroup_bpf_check_dev_permission);static const struct bpf_func_proto * -cgroup_dev_func_proto (enum bpf_func_id func_id) +cgroup_dev_func_proto (enum bpf_func_id func_id, +const struct bpf_prog_extra *prog_extra) {switch (func_id) {case BPF_FUNC_map_lookup_elem:
@@ -566,7 +567,8 @@ cgroup_dev_func_proto(enum bpf_func_id func_id)static bool cgroup_dev_is_valid_access (int off,int size,enum bpf_access_type type, -struct bpf_insn_access_aux *info) +struct bpf_insn_access_aux *info, +const struct bpf_prog_extra *prog_extra) {const int size_default =sizeof (__u32);
kernel/bpf/core.c +4 -1
@@ -142,7 +142,10 @@ struct bpf_prog *bpf_prog_realloc(struct bpf_prog *fp_old, unsigned int size,void __bpf_prog_free (struct bpf_prog *fp) { -kfree (fp->aux); +if (fp->aux) { +kfree (fp->aux->extra); +kfree (fp->aux); + }vfree (fp); }
kernel/bpf/syscall.c +34 -1
@@ -992,6 +992,8 @@ static void __bpf_prog_put(struct bpf_prog *prog, bool do_idr_lock)if (atomic_dec_and_test (&prog->aux->refcnt)) {int i; +if (prog->aux->ops->put_extra && prog->aux->extra) + prog->aux->ops->put_extra (prog->aux->extra);trace_bpf_prog_put_rcu (prog);/* bpf_prog_free_id() must be called first */ bpf_prog_free_id (prog, do_idr_lock);
@@ -1168,7 +1170,7 @@ struct bpf_prog *bpf_prog_get_type_dev(u32 ufd, enum bpf_prog_type type,EXPORT_SYMBOL_GPL (bpf_prog_get_type_dev);/* last field in 'union bpf_attr' used by this command */ -#define BPF_PROG_LOAD_LAST_FIELD prog_ifindex +#define BPF_PROG_LOAD_LAST_FIELD prog_subtype_sizestatic int bpf_prog_load (union bpf_attr *attr) {
@@ -1249,6 +1251,35 @@ static int bpf_prog_load(union bpf_attr *attr)if (err) goto free_prog; +/* copy eBPF program subtype from user space */ +if (attr->prog_subtype) { +u32 size; + + err =check_uarg_tail_zero (u64_to_user_ptr (attr->prog_subtype), +sizeof (prog->aux->extra->subtype), + attr->prog_subtype_size); +if (err) + goto free_prog; + size =min_t (u32, attr->prog_subtype_size, +sizeof (prog->aux->extra->subtype)); + + prog->aux->extra =kzalloc (sizeof (*prog->aux->extra), +GFP_KERNEL |GFP_USER ); +if (!prog->aux->extra) { + err = -ENOMEM ; + goto free_prog; + } +if (copy_from_user (&prog->aux->extra->subtype, +u64_to_user_ptr (attr->prog_subtype), size) + !=0 ) { + err = -EFAULT ; + goto free_prog; + } + }else if (attr->prog_subtype_size !=0 ) { + err = -EINVAL ; + goto free_prog; + } +/* run eBPF verifier */ err =bpf_check (&prog, attr);if (err <0 )
@@ -1281,6 +1312,8 @@ static int bpf_prog_load(union bpf_attr *attr)return err; free_used_maps: +if (prog->aux->ops->put_extra && prog->aux->extra) + prog->aux->ops->put_extra (prog->aux->extra);free_used_maps (prog->aux); free_prog:bpf_prog_uncharge_memlock (prog);
kernel/bpf/verifier.c +16 -3
@@ -1310,7 +1310,8 @@ static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off, };if (env->ops->is_valid_access && - env->ops->is_valid_access (off, size, t, &info)) { + env->ops->is_valid_access (off, size, t, &info, + env->prog->aux->extra)) {/* A non zero info.ctx_field_size indicates that this field is a * candidate for later verifier transformation to load the whole * field and then apply a mask when accessed with a narrower
@@ -2325,7 +2326,8 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn }if (env->ops->get_func_proto) - fn = env->ops->get_func_proto (func_id); + fn = env->ops->get_func_proto (func_id, env->prog->aux->extra); +if (!fn) {verbose (env,"unknown func %s#%d\n" ,func_id_name (func_id), func_id);
@@ -5546,7 +5548,7 @@ static int fixup_bpf_calls(struct bpf_verifier_env *env) insn = new_prog->insnsi + i + delta; } patch_call_imm: - fn = env->ops->get_func_proto (insn->imm); + fn = env->ops->get_func_proto (insn->imm, prog->aux->extra);/* all functions that have prototype and verifier allowed * programs to call them, must be real in-kernel functions */
@@ -5633,6 +5635,17 @@ int bpf_check(struct bpf_prog **prog, union bpf_attr *attr)if (!IS_ENABLED (CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS )) env->strict_alignment = true; +if (env->ops->is_valid_subtype) { +if (!env->ops->is_valid_subtype (env->prog->aux->extra)) { + ret = -EINVAL ; + goto err_unlock; + } + }else if (env->prog->aux->extra) { +/* do not accept a subtype if the program does not handle it */ + ret = -EINVAL ; + goto err_unlock; + } +if (bpf_prog_is_dev_bound (env->prog->aux)) { ret =bpf_prog_offload_verifier_prep (env);if (ret)
kernel/trace/bpf_trace.c +10 -5
@@ -568,7 +568,8 @@ static const struct bpf_func_proto *tracing_func_proto(enum bpf_func_id func_id) } } -static const struct bpf_func_proto *kprobe_prog_func_proto (enum bpf_func_id func_id) +static const struct bpf_func_proto *kprobe_prog_func_proto (enum bpf_func_id func_id, +const struct bpf_prog_extra *prog_extra) {switch (func_id) {case BPF_FUNC_perf_event_output:
@@ -588,7 +589,8 @@ static const struct bpf_func_proto *kprobe_prog_func_proto(enum bpf_func_id func/* bpf+kprobe programs can access fields of 'struct pt_regs' */ static bool kprobe_prog_is_valid_access (int off,int size,enum bpf_access_type type, -struct bpf_insn_access_aux *info) +struct bpf_insn_access_aux *info, +const struct bpf_prog_extra *prog_extra) {if (off <0 || off >=sizeof (struct pt_regs ))return false;
@@ -687,7 +689,8 @@ static const struct bpf_func_proto bpf_perf_prog_read_value_proto_tp = { .arg3_type = ARG_CONST_SIZE, }; -static const struct bpf_func_proto *tp_prog_func_proto (enum bpf_func_id func_id) +static const struct bpf_func_proto *tp_prog_func_proto (enum bpf_func_id func_id, +const struct bpf_prog_extra *prog_extra) {switch (func_id) {case BPF_FUNC_perf_event_output:
@@ -702,7 +705,8 @@ static const struct bpf_func_proto *tp_prog_func_proto(enum bpf_func_id func_id) }static bool tp_prog_is_valid_access (int off,int size,enum bpf_access_type type, -struct bpf_insn_access_aux *info) +struct bpf_insn_access_aux *info, +const struct bpf_prog_extra *prog_extra) {if (off <sizeof (void *) || off >=PERF_MAX_TRACE_SIZE )return false;
@@ -724,7 +728,8 @@ const struct bpf_prog_ops tracepoint_prog_ops = { };static bool pe_prog_is_valid_access (int off,int size,enum bpf_access_type type, -struct bpf_insn_access_aux *info) +struct bpf_insn_access_aux *info, +const struct bpf_prog_extra *prog_extra) { const int size_sp = FIELD_SIZEOF(struct bpf_perf_event_data, sample_period);
net/core/filter.c +47 -29
229 lines not on this page · raw message
samples/bpf/bpf_load.c +2 -1
@@ -72,6 +72,7 @@ static int load_and_attach(const char *event, struct bpf_insn *prog, int size)char buf[256 ];int fd, efd, err, id;struct perf_event_attr attr = {}; +union bpf_prog_subtype *st =NULL ; attr.type =PERF_TYPE_TRACEPOINT ; attr.sample_type =PERF_SAMPLE_RAW ;
@@ -102,7 +103,7 @@ static int load_and_attach(const char *event, struct bpf_insn *prog, int size) } fd =bpf_load_program (prog_type, prog, insns_cnt, license, kern_version, - bpf_log_buf,BPF_LOG_BUF_SIZE ); + bpf_log_buf,BPF_LOG_BUF_SIZE , st);if (fd <0 ) {printf ("bpf_load_program() err=%d\n%s" , errno, bpf_log_buf);return -1 ;
samples/bpf/cookie_uid_helper_example.c +1 -1
@@ -159,7 +159,7 @@ static void prog_load(void) }; prog_fd =bpf_load_program (BPF_PROG_TYPE_SOCKET_FILTER , prog,ARRAY_SIZE (prog),"GPL" ,0 , - log_buf,sizeof (log_buf)); + log_buf,sizeof (log_buf),NULL );if (prog_fd <0 )error (1 , errno,"failed to load prog\n%s\n" , log_buf); }
samples/bpf/fds_example.c +1 -1
@@ -62,7 +62,7 @@ static int bpf_prog_create(const char *object) }else {return bpf_load_program (BPF_PROG_TYPE_SOCKET_FILTER , insns, insns_cnt,"GPL" ,0 , - bpf_log_buf,BPF_LOG_BUF_SIZE ); + bpf_log_buf,BPF_LOG_BUF_SIZE ,NULL ); } }
samples/bpf/sock_example.c +2 -1
@@ -60,7 +60,8 @@ static int test_sock(void)size_t insns_cnt =sizeof (prog) /sizeof (struct bpf_insn ); prog_fd =bpf_load_program (BPF_PROG_TYPE_SOCKET_FILTER , prog, insns_cnt, -"GPL" ,0 , bpf_log_buf,BPF_LOG_BUF_SIZE ); +"GPL" ,0 , bpf_log_buf,BPF_LOG_BUF_SIZE , +NULL );if (prog_fd <0 ) {printf ("failed to load prog '%s'\n" ,strerror (errno)); goto cleanup;
samples/bpf/test_cgrp2_attach.c +1 -1
@@ -72,7 +72,7 @@ static int prog_load(int map_fd, int verdict)return bpf_load_program (BPF_PROG_TYPE_CGROUP_SKB , prog, insns_cnt,"GPL" ,0 , - bpf_log_buf,BPF_LOG_BUF_SIZE ); + bpf_log_buf,BPF_LOG_BUF_SIZE ,NULL ); }static int usage (const char *argv0)
samples/bpf/test_cgrp2_attach2.c +2 -2
@@ -45,7 +45,7 @@ static int prog_load(int verdict) ret =bpf_load_program (BPF_PROG_TYPE_CGROUP_SKB , prog, insns_cnt,"GPL" ,0 , - bpf_log_buf,BPF_LOG_BUF_SIZE ); + bpf_log_buf,BPF_LOG_BUF_SIZE ,NULL );if (ret <0 ) {log_err ("Loading program" );
@@ -229,7 +229,7 @@ static int prog_load_cnt(int verdict, int val) ret =bpf_load_program (BPF_PROG_TYPE_CGROUP_SKB , prog, insns_cnt,"GPL" ,0 , - bpf_log_buf,BPF_LOG_BUF_SIZE ); + bpf_log_buf,BPF_LOG_BUF_SIZE ,NULL );if (ret <0 ) {log_err ("Loading program" );
samples/bpf/test_cgrp2_sock.c +1 -1
@@ -115,7 +115,7 @@ static int prog_load(__u32 idx, __u32 mark, __u32 prio) insns_cnt /=sizeof (struct bpf_insn ); ret =bpf_load_program (BPF_PROG_TYPE_CGROUP_SOCK , prog, insns_cnt, -"GPL" ,0 , bpf_log_buf,BPF_LOG_BUF_SIZE ); +"GPL" ,0 , bpf_log_buf,BPF_LOG_BUF_SIZE ,NULL );free (prog);
tools/include/uapi/linux/bpf.h +11 -0
@@ -231,6 +231,15 @@ enum bpf_attach_type {#define BPF_F_RDONLY (1U << 3)#define BPF_F_WRONLY (1U << 4) +union bpf_prog_subtype { +struct { +__u32 type;/* enum landlock_hook_type */ +__aligned_u64 triggers;/* LANDLOCK_TRIGGER_* */ +__aligned_u64 options;/* LANDLOCK_OPTION_* */ +__u32 previous;/* chained program FD */ + } landlock_hook; +} __attribute__((aligned (8 ))); +union bpf_attr {struct {/* anonymous struct used by BPF_MAP_CREATE command */ __u32 map_type;/* one of enum bpf_map_type */
@@ -270,6 +279,8 @@ union bpf_attr {__u32 prog_flags;char prog_name[BPF_OBJ_NAME_LEN ];__u32 prog_ifindex;/* ifindex of netdev to prep for */ +__aligned_u64 prog_subtype;/* bpf_prog_subtype address */ +__u32 prog_subtype_size; };struct {/* anonymous struct used by BPF_OBJ_* commands */
tools/lib/bpf/bpf.c +11 -4
@@ -150,7 +150,8 @@ int bpf_load_program_name(enum bpf_prog_type type, const char *name,const struct bpf_insn *insns, size_t insns_cnt, const char *license, __u32 kern_version, char *log_buf, - size_t log_buf_sz) + size_t log_buf_sz, + const union bpf_prog_subtype *subtype) { int fd;union bpf_attr attr;
@@ -166,6 +167,8 @@ int bpf_load_program_name(enum bpf_prog_type type, const char *name, attr.log_level =0 ; attr.kern_version = kern_version;memcpy (attr.prog_name, name,min (name_len,BPF_OBJ_NAME_LEN -1 )); + attr.prog_subtype =ptr_to_u64 (subtype); + attr.prog_subtype_size = subtype ?sizeof (*subtype) :0 ; fd =sys_bpf (BPF_PROG_LOAD , &attr,sizeof (attr));if (fd >=0 || !log_buf || !log_buf_sz)
@@ -182,16 +185,18 @@ int bpf_load_program_name(enum bpf_prog_type type, const char *name,int bpf_load_program (enum bpf_prog_type type,const struct bpf_insn *insns,size_t insns_cnt,const char *license,__u32 kern_version,char *log_buf, -size_t log_buf_sz) +size_t log_buf_sz,const union bpf_prog_subtype *subtype) {return bpf_load_program_name (type,NULL , insns, insns_cnt, license, - kern_version, log_buf, log_buf_sz); + kern_version, log_buf, log_buf_sz, + subtype); }int bpf_verify_program (enum bpf_prog_type type,const struct bpf_insn *insns,size_t insns_cnt,int strict_alignment,const char *license,__u32 kern_version, -char *log_buf,size_t log_buf_sz,int log_level) +char *log_buf,size_t log_buf_sz,int log_level, +const union bpf_prog_subtype *subtype) {union bpf_attr attr;
@@ -205,6 +210,8 @@ int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns, attr.log_level = log_level; log_buf[0 ] =0 ; attr.kern_version = kern_version; + attr.prog_subtype =ptr_to_u64 (subtype); + attr.prog_subtype_size = subtype ?sizeof (*subtype) :0 ; attr.prog_flags = strict_alignment ?BPF_F_STRICT_ALIGNMENT :0 ;return sys_bpf (BPF_PROG_LOAD , &attr,sizeof (attr));
tools/lib/bpf/bpf.h +5 -3
@@ -47,15 +47,17 @@ int bpf_load_program_name(enum bpf_prog_type type, const char *name,const struct bpf_insn *insns, size_t insns_cnt, const char *license, __u32 kern_version, char *log_buf, - size_t log_buf_sz); + size_t log_buf_sz, + const union bpf_prog_subtype *subtype);int bpf_load_program (enum bpf_prog_type type,const struct bpf_insn *insns,size_t insns_cnt,const char *license,__u32 kern_version,char *log_buf, -size_t log_buf_sz); +size_t log_buf_sz,const union bpf_prog_subtype *subtype);int bpf_verify_program (enum bpf_prog_type type,const struct bpf_insn *insns,size_t insns_cnt,int strict_alignment,const char *license,__u32 kern_version, -char *log_buf,size_t log_buf_sz,int log_level); +char *log_buf,size_t log_buf_sz,int log_level, +const union bpf_prog_subtype *subtype);int bpf_map_update_elem (int fd,const void *key,const void *value,__u64 flags);
tools/lib/bpf/libbpf.c +3 -2
@@ -1175,7 +1175,8 @@ load_program(enum bpf_prog_type type, const char *name, struct bpf_insn *insns,pr_warning ("Alloc log buffer for bpf loader error, continue without log\n" ); ret =bpf_load_program_name (type, name, insns, insns_cnt, license, - kern_version, log_buf,BPF_LOG_BUF_SIZE ); + kern_version, log_buf,BPF_LOG_BUF_SIZE , +NULL );if (ret >=0 ) { *pfd = ret;
@@ -1202,7 +1203,7 @@ load_program(enum bpf_prog_type type, const char *name, struct bpf_insn *insns, fd =bpf_load_program_name (BPF_PROG_TYPE_KPROBE , name, insns, insns_cnt, license, - kern_version,NULL ,0 ); + kern_version,NULL ,0 ,NULL );if (fd >=0 ) {close (fd); ret = -LIBBPF_ERRNO__PROGTYPE ;
tools/perf/tests/bpf.c +1 -1
@@ -306,7 +306,7 @@ static int check_env(void) err =bpf_load_program (BPF_PROG_TYPE_KPROBE , insns,sizeof (insns) /sizeof (insns[0 ]), - license, kver_int,NULL ,0 ); + license, kver_int,NULL ,0 ,NULL );if (err <0 ) {pr_err ("Missing basic BPF support, skip this test: %s\n" ,strerror (errno));
tools/testing/selftests/bpf/test_align.c +1 -1
@@ -625,7 +625,7 @@ static int do_test_single(struct bpf_align_test *test) prog_len =probe_filter_length (prog); fd_prog =bpf_verify_program (prog_type ? :BPF_PROG_TYPE_SOCKET_FILTER , prog, prog_len,1 ,"GPL" ,0 , - bpf_vlog,sizeof (bpf_vlog),2 ); + bpf_vlog,sizeof (bpf_vlog),2 ,NULL );if (fd_prog <0 && test->result !=REJECT ) {printf ("Failed to load program.\n" );printf ("%s" , bpf_vlog);
tools/testing/selftests/bpf/test_tag.c +1 -1
@@ -58,7 +58,7 @@ static int bpf_try_load_prog(int insns, int fd_map,bpf_filler (insns, fd_map); fd_prog =bpf_load_program (BPF_PROG_TYPE_SCHED_CLS , prog, insns,"" ,0 , -NULL ,0 ); +NULL ,0 ,NULL );assert (fd_prog >0 );if (fd_map >0 )bpf_filler (insns,0 );
tools/testing/selftests/bpf/test_verifier.c +16 -2
@@ -77,6 +77,8 @@ struct bpf_test { } result, result_unpriv;enum bpf_prog_type prog_type;uint8_t flags; +bool has_prog_subtype; +union bpf_prog_subtype prog_subtype; };/* Note we want this to be 64 bit aligned so that the end of our array is
@@ -11228,7 +11230,16 @@ static struct bpf_test tests[] = { .result = ACCEPT, .retval = 2, }, - + { + "superfluous subtype", + .insns = { +BPF_MOV32_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .errstr ="" , + .result = REJECT, + .has_prog_subtype = true, + }, };static int probe_filter_length (const struct bpf_insn *fp)
@@ -11346,6 +11357,8 @@ static void do_test_single(struct bpf_test *test, bool unpriv,const char *expected_err;uint32_t retval;int i, err; +union bpf_prog_subtype *prog_subtype = + test->has_prog_subtype ? &test->prog_subtype :NULL ;for (i =0 ; i <MAX_NR_MAPS ; i++) map_fds[i] =-1 ;
@@ -11354,7 +11367,8 @@ static void do_test_single(struct bpf_test *test, bool unpriv, fd_prog =bpf_verify_program (prog_type ? :BPF_PROG_TYPE_SOCKET_FILTER , prog, prog_len, test->flags &F_LOAD_WITH_STRICT_ALIGNMENT , -"GPL" ,0 , bpf_vlog,sizeof (bpf_vlog),1 ); +"GPL" ,0 , bpf_vlog,sizeof (bpf_vlog),1 , + prog_subtype); expected_ret = unpriv && test->result_unpriv !=UNDEF ? test->result_unpriv : test->result;
Signature · 1 line
2.16.2
Mickaël Salaün
maintainerPATCH v8 4/11 bpf,landlock: Define an eBPF program type for Landlock hooks
In reply to Mickaël SalaünAdd a new type of eBPF program used by Landlock hooks. This type of program can be chained with the same eBPF program type (according to subtype rules). A state can be kept with a value available in the program's context (e.g. named "cookie" for Landlock programs).
This new BPF program type will be registered with the Landlock LSM initialization.
Add an initial Landlock Kconfig and update the MAINTAINERS file.
---
Changes since v7:
* cosmetic fixes
* rename LANDLOCK_SUBTYPE_* to LANDLOCK_*
* cleanup UAPI definitions and move them from bpf.h to landlock.h (suggested by Alexei Starovoitov)
* disable Landlock by default (suggested by Alexei Starovoitov)
* rename BPF_PROG_TYPE_LANDLOCK_{RULE,HOOK}
* update the Kconfig
* update the MAINTAINERS file
* replace the IOCTL, LOCK and FCNTL events with FS_PICK, FS_WALK and FS_GET hook types
* add the ability to chain programs with an eBPF program file descriptor (i.e. the "previous" field in a Landlock subtype) and keep a state with a "cookie" value available from the context
* add a "triggers" subtype bitfield to match specific actions (e.g. append, chdir, read...)
Changes since v6:
* add 3 more sub-events: IOCTL, LOCK, FCNTL
https://lkml.kernel.org/r/[email protected]
* rename LANDLOCK_VERSION to LANDLOCK_ABI to better reflect its purpose, and move it from landlock.h to common.h
* rename BPF_PROG_TYPE_LANDLOCK to BPF_PROG_TYPE_LANDLOCK_RULE: an eBPF program could be used for something else than a rule
* simplify struct landlock_context by removing the arch and syscall_nr fields
* remove all eBPF map functions call, remove ABILITY_WRITE
* refactor bpf_landlock_func_proto() (suggested by Kees Cook)
* constify pointers
* fix doc inclusion
Changes since v5:
* rename file hooks.c to init.c
* fix spelling
Changes since v4:
* merge a minimal (not enabled) LSM code and Kconfig in this commit
Changes since v3:
* split commit
* revamp the landlock_context:
* add arch, syscall_nr and syscall_cmd (ioctl, fcntl…) to be able to cross-check action with the event type
* replace args array with dedicated fields to ease the addition of new fields
--- MAINTAINERS | 13 +++ include/linux/bpf_types.h | 3 + include/uapi/linux/bpf.h | 1 + include/uapi/linux/landlock.h | 155 +++++++++++++++++++++++++++++++ security/Kconfig | 1 + security/Makefile | 2 + security/landlock/Kconfig | 18 ++++ security/landlock/Makefile | 3 + security/landlock/common.h | 32 +++++++ security/landlock/init.c | 180 ++++++++++++++++++++++++++++++++++++ tools/include/uapi/linux/bpf.h | 1 + tools/include/uapi/linux/landlock.h | 155 +++++++++++++++++++++++++++++++ 12 files changed, 564 insertions(+) create mode 100644 include/uapi/linux/landlock.h create mode 100644 security/landlock/Kconfig create mode 100644 security/landlock/Makefile create mode 100644 security/landlock/common.h create mode 100644 security/landlock/init.c create mode 100644 tools/include/uapi/linux/landlock.h
MAINTAINERS +13 -0
@@ -7882,6 +7882,19 @@ S: Maintained F: net/l3mdev F: include/net/l3mdev.h +LANDLOCK SECURITY MODULE +M: Mickaël Salaün <[email protected]> +S: Supported +F: Documentation/security/landlock/ +F: include/linux/landlock.h +F: include/uapi/linux/landlock.h +F: samples/bpf/landlock* +F: security/landlock/ +F: tools/include/uapi/linux/landlock.h +F: tools/testing/selftests/landlock/ +K: landlock +K: LANDLOCK + LANTIQ MIPS ARCHITECTURE M: John Crispin <[email protected]> L: [email protected]
include/linux/bpf_types.h +3 -0
@@ -22,6 +22,9 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_PERF_EVENT, perf_event)#ifdef CONFIG_CGROUP_BPF BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_DEVICE, cg_dev)#endif +#ifdef CONFIG_SECURITY_LANDLOCK +BPF_PROG_TYPE(BPF_PROG_TYPE_LANDLOCK_HOOK, landlock) +#endif BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)BPF_MAP_TYPE (BPF_MAP_TYPE_PERCPU_ARRAY , percpu_array_map_ops)
include/uapi/linux/bpf.h +1 -0
@@ -133,6 +133,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_SOCK_OPS ,BPF_PROG_TYPE_SK_SKB ,BPF_PROG_TYPE_CGROUP_DEVICE , + BPF_PROG_TYPE_LANDLOCK_HOOK, }; enum bpf_attach_type {
include/uapi/linux/landlock.h new file +155 -0
155 lines not on this page · raw message
security/Kconfig +1 -0
@@ -237,6 +237,7 @@ source security/tomoyo/Kconfig source security/apparmor/Kconfig source security/loadpin/Kconfig source security/yama/Kconfig +source security/landlock/Kconfig source security/integrity/Kconfig
security/Makefile +2 -0
@@ -10,6 +10,7 @@ subdir-$(CONFIG_SECURITY_TOMOYO) += tomoyo subdir-$(CONFIG_SECURITY_APPARMOR) += apparmor subdir-$(CONFIG_SECURITY_YAMA) += yama subdir-$(CONFIG_SECURITY_LOADPIN) += loadpin +subdir-$(CONFIG_SECURITY_LANDLOCK) += landlock # always enable default capabilities obj-y += commoncap.o
@@ -25,6 +26,7 @@ obj-$(CONFIG_SECURITY_TOMOYO) += tomoyo/ obj-$(CONFIG_SECURITY_APPARMOR) += apparmor/ obj-$(CONFIG_SECURITY_YAMA) += yama/ obj-$(CONFIG_SECURITY_LOADPIN) += loadpin/ +obj-$(CONFIG_SECURITY_LANDLOCK) += landlock/ obj-$(CONFIG_CGROUP_DEVICE) += device_cgroup.o # Object integrity file lists
security/landlock/Kconfig new file +18 -0
@@ -0,0 +1,18 @@ +config SECURITY_LANDLOCK + bool "Landlock support" + depends on SECURITY + depends on BPF_SYSCALL + depends on SECCOMP_FILTER + default n + help + This selects Landlock, a programmatic access control. It enables to + restrict processes on the fly (i.e. create a sandbox). The security + policy is a set of eBPF programs, dedicated to deny a list of actions + on specific kernel objects (e.g. file). + + You need to enable seccomp filter to apply a security policy to a + process hierarchy (e.g. application with built-in sandboxing). + + See Documentation/security/landlock/ for further information. + + If you are unsure how to answer this question, answer N.
security/landlock/Makefile new file +3 -0
@@ -0,0 +1,3 @@ +obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o + +landlock-y := init.o
security/landlock/common.h new file +32 -0
@@ -0,0 +1,32 @@ +/* +* Landlock LSM - private headers +* +* Copyright © 2016-2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#ifndef _SECURITY_LANDLOCK_COMMON_H +#define _SECURITY_LANDLOCK_COMMON_H + +#include <linux/bpf.h> /* enum bpf_prog_aux */ +#include <linux/filter.h> /* bpf_prog */ +#include <linux/refcount.h> /* refcount_t */ +#include <uapi/linux/landlock.h> /* enum landlock_hook_type */ + +#define LANDLOCK_NAME "landlock" + +/* UAPI bounds and bitmasks */ + +#define _LANDLOCK_HOOK_LAST LANDLOCK_HOOK_FS_GET + +#define _LANDLOCK_OPTION_LAST LANDLOCK_OPTION_PREVIOUS +#define _LANDLOCK_OPTION_MASK ((_LANDLOCK_OPTION_LAST << 1ULL) - 1) + +#define _LANDLOCK_TRIGGER_FS_PICK_LAST LANDLOCK_TRIGGER_FS_PICK_WRITE +#define _LANDLOCK_TRIGGER_FS_PICK_MASK ((_LANDLOCK_TRIGGER_FS_PICK_LAST << 1ULL) - 1) + +#endif /* _SECURITY_LANDLOCK_COMMON_H */
security/landlock/init.c new file +180 -0
180 lines not on this page · raw message
tools/include/uapi/linux/bpf.h +1 -0
@@ -133,6 +133,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_SOCK_OPS ,BPF_PROG_TYPE_SK_SKB ,BPF_PROG_TYPE_CGROUP_DEVICE , + BPF_PROG_TYPE_LANDLOCK_HOOK, }; enum bpf_attach_type {
tools/include/uapi/linux/landlock.h new file +155 -0
155 lines not on this page · raw message
Signature · 1 line
2.16.2
Mickaël Salaün
maintainerPATCH v8 5/11 seccomp,landlock: Enforce Landlock programs per process hierarchy
In reply to Mickaël SalaünThe seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a fs_pick program can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loaded fs_walk program with multiple chains of fs_pick programs).
---
Changes since v7:
* handle and verify program chains
* split and rename providers.c to enforce.c and enforce_seccomp.c
* rename LANDLOCK_SUBTYPE_* to LANDLOCK_*
Changes since v6:
* rename some functions with more accurate names to reflect that an eBPF program for Landlock could be used for something else than a rule
* reword rule "appending" to "prepending" and explain it
* remove the superfluous no_new_privs check, only check global CAP_SYS_ADMIN when prepending a Landlock rule (needed for containers)
* create and use {get,put}_seccomp_landlock() (suggested by Kees Cook)
* replace ifdef with static inlined function (suggested by Kees Cook)
* use get_user() (suggested by Kees Cook)
* replace atomic_t with refcount_t (requested by Kees Cook)
* move struct landlock_{rule,events} from landlock.h to common.h
* cleanup headers
Changes since v5:
* remove struct landlock_node and use a similar inheritance mechanisme as seccomp-bpf (requested by Andy Lutomirski)
* rename SECCOMP_ADD_LANDLOCK_RULE to SECCOMP_APPEND_LANDLOCK_RULE
* rename file manager.c to providers.c
* add comments
* typo and cosmetic fixes
Changes since v4:
* merge manager and seccomp patches
* return -EFAULT in seccomp(2) when user_bpf_fd is null to easely check if Landlock is supported
* only allow a process with the global CAP_SYS_ADMIN to use Landlock (will be lifted in the future)
* add an early check to exit as soon as possible if the current process does not have Landlock rules
Changes since v3:
* remove the hard link with seccomp (suggested by Andy Lutomirski and Kees Cook):
* remove the cookie which could imply multiple evaluation of Landlock rules
* remove the origin field in struct landlock_data
* remove documentation fix (merged upstream)
* rename the new seccomp command to SECCOMP_ADD_LANDLOCK_RULE
* internal renaming
* split commit
* new design to be able to inherit on the fly the parent rules
Changes since v2:
* Landlock programs can now be run without seccomp filter but for any syscall (from the process) or interruption
* move Landlock related functions and structs into security/landlock/* (to manage cgroups as well)
* fix seccomp filter handling: run Landlock programs for each of their legitimate seccomp filter
* properly clean up all seccomp results
* cosmetic changes to ease the understanding
* fix some ifdef
--- include/linux/landlock.h | 37 ++++ include/linux/seccomp.h | 5 + include/uapi/linux/seccomp.h | 1 + kernel/fork.c | 8 +- kernel/seccomp.c | 4 + security/landlock/Makefile | 3 +- security/landlock/chain.c | 39 ++++ security/landlock/chain.h | 35 ++++ security/landlock/common.h | 53 +++++ security/landlock/enforce.c | 386 ++++++++++++++++++++++++++++++++++++ security/landlock/enforce.h | 21 ++ security/landlock/enforce_seccomp.c | 102 ++++++++++ 12 files changed, 692 insertions(+), 2 deletions(-) create mode 100644 include/linux/landlock.h create mode 100644 security/landlock/chain.c create mode 100644 security/landlock/chain.h create mode 100644 security/landlock/enforce.c create mode 100644 security/landlock/enforce.h create mode 100644 security/landlock/enforce_seccomp.c
include/linux/landlock.h new file +37 -0
@@ -0,0 +1,37 @@ +/* +* Landlock LSM - public kernel headers +* +* Copyright © 2016-2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#ifndef _LINUX_LANDLOCK_H +#define _LINUX_LANDLOCK_H + +#include <linux/errno.h> +#include <linux/sched.h> /* task_struct */ + +#if defined(CONFIG_SECCOMP_FILTER ) && defined(CONFIG_SECURITY_LANDLOCK ) +extern int landlock_seccomp_prepend_prog (unsigned int flags, +const int __user *user_bpf_fd); +extern void put_seccomp_landlock (struct task_struct *tsk); +extern void get_seccomp_landlock (struct task_struct *tsk); +#else /* CONFIG_SECCOMP_FILTER && CONFIG_SECURITY_LANDLOCK */ +static inline int landlock_seccomp_prepend_prog (unsigned int flags, +const int __user *user_bpf_fd) +{ +return -EINVAL ; +} +static inline void put_seccomp_landlock (struct task_struct *tsk) +{ +} +static inline void get_seccomp_landlock (struct task_struct *tsk) +{ +} +#endif /* CONFIG_SECCOMP_FILTER && CONFIG_SECURITY_LANDLOCK */ + +#endif /* _LINUX_LANDLOCK_H */
include/linux/seccomp.h +5 -0
@@ -9,6 +9,7 @@#ifdef CONFIG_SECCOMP +#include <linux/landlock.h> #include <linux/thread_info.h> #include <asm/seccomp.h>
@@ -20,6 +21,7 @@ struct seccomp_filter;* system calls available to a process. * @filter: must always point to a valid seccomp-filter or NULL as it is * accessed without locking during system call entry. +* @landlock_prog_set: contains a set of Landlock programs. * * @filter must only be accessed from the context of current as there * is no read locking.
@@ -27,6 +29,9 @@ struct seccomp_filter;struct seccomp {int mode;struct seccomp_filter *filter; +#if defined(CONFIG_SECCOMP_FILTER ) && defined(CONFIG_SECURITY_LANDLOCK ) +struct landlock_prog_set *landlock_prog_set; +#endif /* CONFIG_SECCOMP_FILTER && CONFIG_SECURITY_LANDLOCK */ };#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER
include/uapi/linux/seccomp.h +1 -0
@@ -15,6 +15,7 @@#define SECCOMP_SET_MODE_STRICT 0#define SECCOMP_SET_MODE_FILTER 1#define SECCOMP_GET_ACTION_AVAIL 2 +#define SECCOMP_PREPEND_LANDLOCK_PROG 3/* Valid flags for SECCOMP_SET_MODE_FILTER */ #define SECCOMP_FILTER_FLAG_TSYNC 1
kernel/fork.c +7 -1
@@ -48,6 +48,7 @@#include <linux/security.h> #include <linux/hugetlb.h> #include <linux/seccomp.h> +#include <linux/landlock.h> #include <linux/swap.h> #include <linux/syscalls.h> #include <linux/jiffies.h>
@@ -385,6 +386,7 @@ void free_task(struct task_struct *tsk)rt_mutex_debug_task_free (tsk);ftrace_graph_exit_task (tsk);put_seccomp_filter (tsk); +put_seccomp_landlock (tsk);arch_release_task_struct (tsk);if (tsk->flags &PF_KTHREAD )free_kthread_struct (tsk);
@@ -814,7 +816,10 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node)* the usage counts on the error path calling free_task. */ tsk->seccomp.filter =NULL ; -#endif +#ifdef CONFIG_SECURITY_LANDLOCK + tsk->seccomp.landlock_prog_set =NULL ; +#endif /* CONFIG_SECURITY_LANDLOCK */ +#endif /* CONFIG_SECCOMP */ setup_thread_stack (tsk, orig);clear_user_return_notifier (tsk);
@@ -1496,6 +1501,7 @@ static void copy_seccomp(struct task_struct *p)/* Ref-count the new filter user, and assign it. */ get_seccomp_filter (current); +get_seccomp_landlock (current); p->seccomp = current->seccomp;/*
kernel/seccomp.c +4 -0
@@ -37,6 +37,7 @@#include <linux/security.h> #include <linux/tracehook.h> #include <linux/uaccess.h> +#include <linux/landlock.h> /** * struct seccomp_filter - container for seccomp BPF programs
@@ -932,6 +933,9 @@ static long do_seccomp(unsigned int op, unsigned int flags,return -EINVAL ;return seccomp_get_action_avail (uargs); +case SECCOMP_PREPEND_LANDLOCK_PROG : +return landlock_seccomp_prepend_prog (flags, + (const int __user *)uargs);default :return -EINVAL ; }
security/landlock/Makefile +2 -1
@@ -1,3 +1,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o -landlock-y := init.o +landlock-y := init.o chain.o \ + enforce.o enforce_seccomp.o
security/landlock/chain.c new file +39 -0
@@ -0,0 +1,39 @@ +/* +* Landlock LSM - chain helpers +* +* Copyright © 2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <linux/refcount.h> +#include <linux/slab.h> + +#include "chain.h" + +/* TODO: use a dedicated kmem_cache_alloc() instead of k*alloc() */ + +/* never return NULL */ +struct landlock_chain *landlock_new_chain (u8 index) +{ +struct landlock_chain *chain; + + chain =kzalloc (sizeof (*chain),GFP_KERNEL ); +if (!chain) +return ERR_PTR (-ENOMEM ); + chain->index = index; +refcount_set (&chain->usage,1 ); +return chain; +} + +void landlock_put_chain (struct landlock_chain *chain) +{ +if (!chain) +return ; +if (!refcount_dec_and_test (&chain->usage)) +return ; +kfree (chain); +}
security/landlock/chain.h new file +35 -0
@@ -0,0 +1,35 @@ +/* +* Landlock LSM - chain headers +* +* Copyright © 2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#ifndef _SECURITY_LANDLOCK_CHAIN_H +#define _SECURITY_LANDLOCK_CHAIN_H + +#include <linux/landlock.h> /* struct landlock_chain */ +#include <linux/refcount.h> + +/* +* @chain_index: index of the chain (defined by the user, different from a +* program list) +* @next: point to the next sibling in the same prog_set (used to match a chain +* against the current process) +* @index: index in the array dedicated to store data for a chain instance +*/ +struct landlock_chain { +struct landlock_chain *next; +refcount_t usage; +u8 index; +u8 shared:1 ; +}; + +struct landlock_chain *landlock_new_chain (u8 index); +void landlock_put_chain (struct landlock_chain *chain); + +#endif /* _SECURITY_LANDLOCK_CHAIN_H */
security/landlock/common.h +53 -0
57 lines not on this page · raw message
security/landlock/enforce.c new file +386 -0
386 lines not on this page · raw message
security/landlock/enforce.h new file +21 -0
@@ -0,0 +1,21 @@ +/* +* Landlock LSM - enforcing helpers headers +* +* Copyright © 2016-2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#ifndef _SECURITY_LANDLOCK_ENFORCE_H +#define _SECURITY_LANDLOCK_ENFORCE_H + +struct landlock_prog_set *landlock_prepend_prog ( +struct landlock_prog_set *current_prog_set, +struct bpf_prog *prog); +void landlock_put_prog_set (struct landlock_prog_set *prog_set); +void landlock_get_prog_set (struct landlock_prog_set *prog_set); + +#endif /* _SECURITY_LANDLOCK_ENFORCE_H */
security/landlock/enforce_seccomp.c new file +102 -0
102 lines not on this page · raw message
Signature · 1 line
2.16.2
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>
...
Quoted 96 lines
security/landlock/enforce.c new file +96
-0+struct landlock_prog_set *landlock_prepend_prog ( +struct landlock_prog_set *current_prog_set, +struct bpf_prog *prog) +{ +struct landlock_prog_set *new_prog_set = current_prog_set; +unsigned long pages; +int err; +size_t i; +struct landlock_prog_set tmp_prog_set = {}; + +if (prog->type !=BPF_PROG_TYPE_LANDLOCK_HOOK ) +return ERR_PTR (-EINVAL ); + +/* validate memory size allocation */ + pages = prog->pages; +if (current_prog_set) { +size_t i; + +for (i =0 ; i <ARRAY_SIZE (current_prog_set->programs); i++) { +struct landlock_prog_list *walker_p; + +for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } +/* count a struct landlock_prog_set if we need to allocate one */ +if (refcount_read (¤t_prog_set->usage) !=1 ) + pages +=round_up (sizeof (*current_prog_set),PAGE_SIZE ) + /PAGE_SIZE ; + } +if (pages >LANDLOCK_PROGRAMS_MAX_PAGES ) +return ERR_PTR (-E2BIG ); + +/* ensure early that we can allocate enough memory for the new +* prog_lists */ + err =store_landlock_prog (&tmp_prog_set, current_prog_set, prog); +if (err) +return ERR_PTR (err); + +/* +* Each task_struct points to an array of prog list pointers. These +* tables are duplicated when additions are made (which means each +* table needs to be refcounted for the processes using it). When a new +* table is created, all the refcounters on the prog_list are bumped (to +* track each table that references the prog). When a new prog is +* added, it's just prepended to the list for the new table to point +* at. +* +* Manage all the possible errors before this step to not uselessly +* duplicate current_prog_set and avoid a rollback. +*/ +if (!new_prog_set) { +/* +* If there is no Landlock program set used by the current task, +* then create a new one. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; + }else if (refcount_read (¤t_prog_set->usage) >1 ) { +/* +* If the current task is not the sole user of its Landlock +* program set, then duplicate them. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; +for (i =0 ; i <ARRAY_SIZE (new_prog_set->programs); i++) { + new_prog_set->programs[i] = +READ_ONCE (current_prog_set->programs[i]); +if (new_prog_set->programs[i]) +refcount_inc (&new_prog_set->programs[i]->usage); + } + +/* +* Landlock program set from the current task will not be freed +* here because the usage is strictly greater than 1. It is +* only prevented to be freed by another task thanks to the +* caller of landlock_prepend_prog() which should be locked if +* needed. +*/ +landlock_put_prog_set (current_prog_set); + } + +/* prepend tmp_prog_set to new_prog_set */ +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) { +/* get the last new list */ +struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + +if (last_list) { +while (last_list->prev) + last_list = last_list->prev; +/* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i];
security/landlock/enforce.c line 386
Quoted 10 lines
security/landlock/enforce.c new file +10
-0+ } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; +return new_prog_set; + +put_tmp_lists: +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) +put_landlock_prog_list (tmp_prog_set.programs[i]); +return new_prog_set; +}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed via BPF_PROG_RUN_ARRAY.
Please use that instead.
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
security/landlock/enforce.c new file +105
-0+struct landlock_prog_set *landlock_prepend_prog ( +struct landlock_prog_set *current_prog_set, +struct bpf_prog *prog) +{ +struct landlock_prog_set *new_prog_set = current_prog_set; +unsigned long pages; +int err; +size_t i; +struct landlock_prog_set tmp_prog_set = {}; + +if (prog->type !=BPF_PROG_TYPE_LANDLOCK_HOOK ) +return ERR_PTR (-EINVAL ); + +/* validate memory size allocation */ + pages = prog->pages; +if (current_prog_set) { +size_t i; + +for (i =0 ; i <ARRAY_SIZE (current_prog_set->programs); i++) { +struct landlock_prog_list *walker_p; + +for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } +/* count a struct landlock_prog_set if we need to allocate one */ +if (refcount_read (¤t_prog_set->usage) !=1 ) + pages +=round_up (sizeof (*current_prog_set),PAGE_SIZE ) + /PAGE_SIZE ; + } +if (pages >LANDLOCK_PROGRAMS_MAX_PAGES ) +return ERR_PTR (-E2BIG ); + +/* ensure early that we can allocate enough memory for the new +* prog_lists */ + err =store_landlock_prog (&tmp_prog_set, current_prog_set, prog); +if (err) +return ERR_PTR (err); + +/* +* Each task_struct points to an array of prog list pointers. These +* tables are duplicated when additions are made (which means each +* table needs to be refcounted for the processes using it). When a new +* table is created, all the refcounters on the prog_list are bumped (to +* track each table that references the prog). When a new prog is +* added, it's just prepended to the list for the new table to point +* at. +* +* Manage all the possible errors before this step to not uselessly +* duplicate current_prog_set and avoid a rollback. +*/ +if (!new_prog_set) { +/* +* If there is no Landlock program set used by the current task, +* then create a new one. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; + }else if (refcount_read (¤t_prog_set->usage) >1 ) { +/* +* If the current task is not the sole user of its Landlock +* program set, then duplicate them. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; +for (i =0 ; i <ARRAY_SIZE (new_prog_set->programs); i++) { + new_prog_set->programs[i] = +READ_ONCE (current_prog_set->programs[i]); +if (new_prog_set->programs[i]) +refcount_inc (&new_prog_set->programs[i]->usage); + } + +/* +* Landlock program set from the current task will not be freed +* here because the usage is strictly greater than 1. It is +* only prevented to be freed by another task thanks to the +* caller of landlock_prepend_prog() which should be locked if +* needed. +*/ +landlock_put_prog_set (current_prog_set); + } + +/* prepend tmp_prog_set to new_prog_set */ +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) { +/* get the last new list */ +struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + +if (last_list) { +while (last_list->prev) + last_list = last_list->prev; +/* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; +return new_prog_set; + +put_tmp_lists: +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) +put_landlock_prog_list (tmp_prog_set.programs[i]); +return new_prog_set;
Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.
I don't see how that would help. Suppose you add a filter, then fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 149 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
security/landlock/enforce.c new file +105
-0+struct landlock_prog_set *landlock_prepend_prog ( +struct landlock_prog_set *current_prog_set, +struct bpf_prog *prog) +{ +struct landlock_prog_set *new_prog_set = current_prog_set; +unsigned long pages; +int err; +size_t i; +struct landlock_prog_set tmp_prog_set = {}; + +if (prog->type !=BPF_PROG_TYPE_LANDLOCK_HOOK ) +return ERR_PTR (-EINVAL ); + +/* validate memory size allocation */ + pages = prog->pages; +if (current_prog_set) { +size_t i; + +for (i =0 ; i <ARRAY_SIZE (current_prog_set->programs); i++) { +struct landlock_prog_list *walker_p; + +for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } +/* count a struct landlock_prog_set if we need to allocate one */ +if (refcount_read (¤t_prog_set->usage) !=1 ) + pages +=round_up (sizeof (*current_prog_set),PAGE_SIZE ) + /PAGE_SIZE ; + } +if (pages >LANDLOCK_PROGRAMS_MAX_PAGES ) +return ERR_PTR (-E2BIG ); + +/* ensure early that we can allocate enough memory for the new +* prog_lists */ + err =store_landlock_prog (&tmp_prog_set, current_prog_set, prog); +if (err) +return ERR_PTR (err); + +/* +* Each task_struct points to an array of prog list pointers. These +* tables are duplicated when additions are made (which means each +* table needs to be refcounted for the processes using it). When a new +* table is created, all the refcounters on the prog_list are bumped (to +* track each table that references the prog). When a new prog is +* added, it's just prepended to the list for the new table to point +* at. +* +* Manage all the possible errors before this step to not uselessly +* duplicate current_prog_set and avoid a rollback. +*/ +if (!new_prog_set) { +/* +* If there is no Landlock program set used by the current task, +* then create a new one. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; + }else if (refcount_read (¤t_prog_set->usage) >1 ) { +/* +* If the current task is not the sole user of its Landlock +* program set, then duplicate them. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; +for (i =0 ; i <ARRAY_SIZE (new_prog_set->programs); i++) { + new_prog_set->programs[i] = +READ_ONCE (current_prog_set->programs[i]); +if (new_prog_set->programs[i]) +refcount_inc (&new_prog_set->programs[i]->usage); + } + +/* +* Landlock program set from the current task will not be freed +* here because the usage is strictly greater than 1. It is +* only prevented to be freed by another task thanks to the +* caller of landlock_prepend_prog() which should be locked if +* needed. +*/ +landlock_put_prog_set (current_prog_set); + } + +/* prepend tmp_prog_set to new_prog_set */ +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) { +/* get the last new list */ +struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + +if (last_list) { +while (last_list->prev) + last_list = last_list->prev; +/* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; +return new_prog_set; + +put_tmp_lists: +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) +put_landlock_prog_list (tmp_prog_set.programs[i]); +return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.
Quoted 7 lines
I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
security/landlock/enforce.c new file +105
-0+struct landlock_prog_set *landlock_prepend_prog ( +struct landlock_prog_set *current_prog_set, +struct bpf_prog *prog) +{ +struct landlock_prog_set *new_prog_set = current_prog_set; +unsigned long pages; +int err; +size_t i; +struct landlock_prog_set tmp_prog_set = {}; + +if (prog->type !=BPF_PROG_TYPE_LANDLOCK_HOOK ) +return ERR_PTR (-EINVAL ); + +/* validate memory size allocation */ + pages = prog->pages; +if (current_prog_set) { +size_t i; + +for (i =0 ; i <ARRAY_SIZE (current_prog_set->programs); i++) { +struct landlock_prog_list *walker_p; + +for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } +/* count a struct landlock_prog_set if we need to allocate one */ +if (refcount_read (¤t_prog_set->usage) !=1 ) + pages +=round_up (sizeof (*current_prog_set),PAGE_SIZE ) + /PAGE_SIZE ; + } +if (pages >LANDLOCK_PROGRAMS_MAX_PAGES ) +return ERR_PTR (-E2BIG ); + +/* ensure early that we can allocate enough memory for the new +* prog_lists */ + err =store_landlock_prog (&tmp_prog_set, current_prog_set, prog); +if (err) +return ERR_PTR (err); + +/* +* Each task_struct points to an array of prog list pointers. These +* tables are duplicated when additions are made (which means each +* table needs to be refcounted for the processes using it). When a new +* table is created, all the refcounters on the prog_list are bumped (to +* track each table that references the prog). When a new prog is +* added, it's just prepended to the list for the new table to point +* at. +* +* Manage all the possible errors before this step to not uselessly +* duplicate current_prog_set and avoid a rollback. +*/ +if (!new_prog_set) { +/* +* If there is no Landlock program set used by the current task, +* then create a new one. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; + }else if (refcount_read (¤t_prog_set->usage) >1 ) { +/* +* If the current task is not the sole user of its Landlock +* program set, then duplicate them. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; +for (i =0 ; i <ARRAY_SIZE (new_prog_set->programs); i++) { + new_prog_set->programs[i] = +READ_ONCE (current_prog_set->programs[i]); +if (new_prog_set->programs[i]) +refcount_inc (&new_prog_set->programs[i]->usage); + } + +/* +* Landlock program set from the current task will not be freed +* here because the usage is strictly greater than 1. It is +* only prevented to be freed by another task thanks to the +* caller of landlock_prepend_prog() which should be locked if +* needed. +*/ +landlock_put_prog_set (current_prog_set); + } + +/* prepend tmp_prog_set to new_prog_set */ +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) { +/* get the last new list */ +struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + +if (last_list) { +while (last_list->prev) + last_list = last_list->prev; +/* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; +return new_prog_set; + +put_tmp_lists: +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) +put_landlock_prog_list (tmp_prog_set.programs[i]); +return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.
Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage across fork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.
For what it's worth, I haven't figured out that Mickaël means about chaining restrictions involving cookies. This seems like something wrong and the design is too complicated.
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 166 lines · Andy Lutomirski
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
security/landlock/enforce.c new file +105
-0+struct landlock_prog_set *landlock_prepend_prog ( +struct landlock_prog_set *current_prog_set, +struct bpf_prog *prog) +{ +struct landlock_prog_set *new_prog_set = current_prog_set; +unsigned long pages; +int err; +size_t i; +struct landlock_prog_set tmp_prog_set = {}; + +if (prog->type !=BPF_PROG_TYPE_LANDLOCK_HOOK ) +return ERR_PTR (-EINVAL ); + +/* validate memory size allocation */ + pages = prog->pages; +if (current_prog_set) { +size_t i; + +for (i =0 ; i <ARRAY_SIZE (current_prog_set->programs); i++) { +struct landlock_prog_list *walker_p; + +for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } +/* count a struct landlock_prog_set if we need to allocate one */ +if (refcount_read (¤t_prog_set->usage) !=1 ) + pages +=round_up (sizeof (*current_prog_set),PAGE_SIZE ) + /PAGE_SIZE ; + } +if (pages >LANDLOCK_PROGRAMS_MAX_PAGES ) +return ERR_PTR (-E2BIG ); + +/* ensure early that we can allocate enough memory for the new +* prog_lists */ + err =store_landlock_prog (&tmp_prog_set, current_prog_set, prog); +if (err) +return ERR_PTR (err); + +/* +* Each task_struct points to an array of prog list pointers. These +* tables are duplicated when additions are made (which means each +* table needs to be refcounted for the processes using it). When a new +* table is created, all the refcounters on the prog_list are bumped (to +* track each table that references the prog). When a new prog is +* added, it's just prepended to the list for the new table to point +* at. +* +* Manage all the possible errors before this step to not uselessly +* duplicate current_prog_set and avoid a rollback. +*/ +if (!new_prog_set) { +/* +* If there is no Landlock program set used by the current task, +* then create a new one. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; + }else if (refcount_read (¤t_prog_set->usage) >1 ) { +/* +* If the current task is not the sole user of its Landlock +* program set, then duplicate them. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; +for (i =0 ; i <ARRAY_SIZE (new_prog_set->programs); i++) { + new_prog_set->programs[i] = +READ_ONCE (current_prog_set->programs[i]); +if (new_prog_set->programs[i]) +refcount_inc (&new_prog_set->programs[i]->usage); + } + +/* +* Landlock program set from the current task will not be freed +* here because the usage is strictly greater than 1. It is +* only prevented to be freed by another task thanks to the +* caller of landlock_prepend_prog() which should be locked if +* needed. +*/ +landlock_put_prog_set (current_prog_set); + } + +/* prepend tmp_prog_set to new_prog_set */ +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) { +/* get the last new list */ +struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + +if (last_list) { +while (last_list->prev) + last_list = last_list->prev; +/* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; +return new_prog_set; + +put_tmp_lists: +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) +put_landlock_prog_list (tmp_prog_set.programs[i]); +return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
Quoted 5 lines
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
+1
if that was the case...
but that's not my reading of the patch set.
Quoted 6 lines
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage acrossfork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.
+1
in cgroup we had to invent this new BPF_PROG_RUN_ARRAY mechanism, since cgroup hierarchy can be complicated with bpf progs attached at different levels with different override/multiprog properties, so walking link list and checking all flags at run-time would have been too slow. That's why we added compute_effective_progs().
imo doing similar stuff at fork is not a big deal either. allocating new bpf_prog_array for the task and computing array of progs is trivial.
Quoted 3 lines
For what it's worth, I haven't figured out that Mickaël means about chaining restrictions involving cookies. This seems like something wrong and the design is too complicated.
the cookie part I don't like either.
In networking land we have cb in skb and xdp metadata to pass data between programs.
imo right now for landlock there is no need to do any of this stuff. It's purely a feature extension that is clearly controversial and blocking even basic review of the rest of the patches.
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 173 lines · Alexei Starovoitov
Quoted 166 lines · Andy Lutomirski
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
security/landlock/enforce.c new file +105
-0+struct landlock_prog_set *landlock_prepend_prog ( +struct landlock_prog_set *current_prog_set, +struct bpf_prog *prog) +{ +struct landlock_prog_set *new_prog_set = current_prog_set; +unsigned long pages; +int err; +size_t i; +struct landlock_prog_set tmp_prog_set = {}; + +if (prog->type !=BPF_PROG_TYPE_LANDLOCK_HOOK ) +return ERR_PTR (-EINVAL ); + +/* validate memory size allocation */ + pages = prog->pages; +if (current_prog_set) { +size_t i; + +for (i =0 ; i <ARRAY_SIZE (current_prog_set->programs); i++) { +struct landlock_prog_list *walker_p; + +for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } +/* count a struct landlock_prog_set if we need to allocate one */ +if (refcount_read (¤t_prog_set->usage) !=1 ) + pages +=round_up (sizeof (*current_prog_set),PAGE_SIZE ) + /PAGE_SIZE ; + } +if (pages >LANDLOCK_PROGRAMS_MAX_PAGES ) +return ERR_PTR (-E2BIG ); + +/* ensure early that we can allocate enough memory for the new +* prog_lists */ + err =store_landlock_prog (&tmp_prog_set, current_prog_set, prog); +if (err) +return ERR_PTR (err); + +/* +* Each task_struct points to an array of prog list pointers. These +* tables are duplicated when additions are made (which means each +* table needs to be refcounted for the processes using it). When a new +* table is created, all the refcounters on the prog_list are bumped (to +* track each table that references the prog). When a new prog is +* added, it's just prepended to the list for the new table to point +* at. +* +* Manage all the possible errors before this step to not uselessly +* duplicate current_prog_set and avoid a rollback. +*/ +if (!new_prog_set) { +/* +* If there is no Landlock program set used by the current task, +* then create a new one. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; + }else if (refcount_read (¤t_prog_set->usage) >1 ) { +/* +* If the current task is not the sole user of its Landlock +* program set, then duplicate them. +*/ + new_prog_set =new_landlock_prog_set (); +if (IS_ERR (new_prog_set)) + goto put_tmp_lists; +for (i =0 ; i <ARRAY_SIZE (new_prog_set->programs); i++) { + new_prog_set->programs[i] = +READ_ONCE (current_prog_set->programs[i]); +if (new_prog_set->programs[i]) +refcount_inc (&new_prog_set->programs[i]->usage); + } + +/* +* Landlock program set from the current task will not be freed +* here because the usage is strictly greater than 1. It is +* only prevented to be freed by another task thanks to the +* caller of landlock_prepend_prog() which should be locked if +* needed. +*/ +landlock_put_prog_set (current_prog_set); + } + +/* prepend tmp_prog_set to new_prog_set */ +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) { +/* get the last new list */ +struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + +if (last_list) { +while (last_list->prev) + last_list = last_list->prev; +/* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; +return new_prog_set; + +put_tmp_lists: +for (i =0 ; i <ARRAY_SIZE (tmp_prog_set.programs); i++) +put_landlock_prog_list (tmp_prog_set.programs[i]); +return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
Quoted 5 lines
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
Quoted 3 lines
+1
if that was the case...
but that's not my reading of the patch set.
An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the seccomp() syscall was awkward for you to use? You could add a seccomp_add_landlock_rule() syscall if you needed to.
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the security_xyz() hooks.
Quoted 8 lines
Quoted 7 lines
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage acrossfork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.
Quoted 6 lines
+1
in cgroup we had to invent this newBPF_PROG_RUN_ARRAYmechanism, since cgroup hierarchy can be complicated with bpf progs attached at different levels with different override/multiprog properties, so walking link list and checking all flags at run-time would have been too slow. That's why we addedcompute_effective_progs().
If we start adding override flags to Landlock, I think we're doing it
wrong. With cgroup bpf programs, the whole mess is set up by the
administrator. With seccomp, and with Landlock if done correctly, it *won't* be set up by the administrator, so the chance that everyone gets all the flags right is about zero. All attached filters should run unconditionally.
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 8 lines · Andy Lutomirski
Quoted 1 line · Alexei Starovoitov
[ Snip ]
An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.
Quoted 4 lines
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.
Please, no. It is my serious intention to have at least the infrastructure blob management in within a release or two, and I think that's all Landlock needs. The security_xyz() hooks are sufficiently hackish as it is without unnecessarily adding more special cases.
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 14 lines · Casey Schaufler
Quoted 8 lines · Andy Lutomirski
Quoted 1 line · Alexei Starovoitov
[ Snip ]
An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.Quoted 4 lines
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.
Quoted 7 lines
Please, no. It is my serious intention to have at least the infrastructure blob management in within a release or two, and I think that's all Landlock needs. The
security_xyz()hooks are sufficiently hackish as it is without unnecessarily adding more special cases.
What do you mean by "infrastructure blob management"?
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 14 lines · Andy Lutomirski
Quoted 13 lines · Casey Schaufler
Quoted 12 lines · Andy Lutomirski
Quoted 1 line · Alexei Starovoitov
[ Snip ]
An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.
Quoted 8 lines
Quoted 7 lines
Please, no. It is my serious intention to have at least the infrastructure blob management in within a release or two, and I think that's all Landlock needs. The
security_xyz()hooks are sufficiently hackish as it is without unnecessarily adding more special cases.What do you mean by "infrastructure blob management"?
Today each security module manages their own module specific data, for example inode->i_security and file->f_security. This prevents having two security modules that have inode or file data from being used at the same time, because they both need to manage those fields. Moving the management of the module specific data (aka "blobs") from the security modules to the module infrastructure will allow those modules to coexist. Restrictions apply, of course, but I don't think that Landlock uses any of the facilities that would have issues.
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
In reply to Andy LutomirskiQuoted 175 lines · Andy Lutomirski
Quoted 173 lines · Alexei Starovoitov
Quoted 171 lines · Andy Lutomirski
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
(quoted diff) +105
-0+struct landlock_prog_set *landlock_prepend_prog( + struct landlock_prog_set *current_prog_set, + struct bpf_prog *prog) +{ + struct landlock_prog_set *new_prog_set = current_prog_set; + unsigned long pages; + int err; + size_t i; + struct landlock_prog_set tmp_prog_set = {}; + + if (prog->type != BPF_PROG_TYPE_LANDLOCK_HOOK) + return ERR_PTR(-EINVAL); + + /* validate memory size allocation */ + pages = prog->pages; + if (current_prog_set) { + size_t i; + + for (i = 0; i < ARRAY_SIZE(current_prog_set->programs); i++) { + struct landlock_prog_list *walker_p; + + for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } + /* count a struct landlock_prog_set if we need to allocate one */ + if (refcount_read(¤t_prog_set->usage) != 1) + pages += round_up(sizeof(*current_prog_set), PAGE_SIZE) + / PAGE_SIZE; + } + if (pages > LANDLOCK_PROGRAMS_MAX_PAGES) + return ERR_PTR(-E2BIG); + + /* ensure early that we can allocate enough memory for the new + * prog_lists */ + err = store_landlock_prog(&tmp_prog_set, current_prog_set, prog); + if (err) + return ERR_PTR(err); + + /* + * Each task_struct points to an array of prog list pointers. These + * tables are duplicated when additions are made (which means each + * table needs to be refcounted for the processes using it). When a new + * table is created, all the refcounters on the prog_list are bumped (to + * track each table that references the prog). When a new prog is + * added, it's just prepended to the list for the new table to point + * at. + * + * Manage all the possible errors before this step to not uselessly + * duplicate current_prog_set and avoid a rollback. + */ + if (!new_prog_set) { + /* + * If there is no Landlock program set used by the current task, + * then create a new one. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + } else if (refcount_read(¤t_prog_set->usage) > 1) { + /* + * If the current task is not the sole user of its Landlock + * program set, then duplicate them. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + for (i = 0; i < ARRAY_SIZE(new_prog_set->programs); i++) { + new_prog_set->programs[i] = + READ_ONCE(current_prog_set->programs[i]); + if (new_prog_set->programs[i]) + refcount_inc(&new_prog_set->programs[i]->usage); + } + + /* + * Landlock program set from the current task will not be freed + * here because the usage is strictly greater than 1. It is + * only prevented to be freed by another task thanks to the + * caller of landlock_prepend_prog() which should be locked if + * needed. + */ + landlock_put_prog_set(current_prog_set); + } + + /* prepend tmp_prog_set to new_prog_set */ + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) { + /* get the last new list */ + struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + + if (last_list) { + while (last_list->prev) + last_list = last_list->prev; + /* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; + return new_prog_set; + +put_tmp_lists: + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) + put_landlock_prog_list(tmp_prog_set.programs[i]); + return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
Quoted 8 lines
Quoted 3 lines
+1
if that was the case...
but that's not my reading of the patch set.An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.
Nothing was wrong about about that, this part did not changed (see my next comment).
Quoted 5 lines
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.
See Casey's answer and his patch series: https://lwn.net/Articles/741963/
Quoted 16 lines
Quoted 9 lines
Quoted 8 lines
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage acrossfork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.Quoted 6 lines
+1
in cgroup we had to invent this newBPF_PROG_RUN_ARRAYmechanism, since cgroup hierarchy can be complicated with bpf progs attached at different levels with different override/multiprog properties, so walking link list and checking all flags at run-time would have been too slow. That's why we addedcompute_effective_progs().
Quoted 6 lines
If we start adding override flags to Landlock, I think we're doing it
wrong. With cgroup bpf programs, the whole mess is set up by the
administrator. With seccomp, and with Landlock if done correctly, it *won't* be set up by the administrator, so the chance that everyone gets all the flags right is about zero. All attached filters should run unconditionally.
There is a misunderstanding about this chaining mechanism. This should not be confused with the list of seccomp filters nor the cgroup hierarchies. Landlock programs can be stacked the same way seccomp's filters can (cf. struct landlock_prog_set, the "chain_last" field is an optimization which is not used for this struct handling). This stackable property did not changed from the previous patch series. The chaining mechanism is for another use case, which does not make sense for seccomp filters nor other eBPF program types, at least for now, from what I can tell.
You may want to get a look at my talk at FOSDEM
(https://landlock.io/talks/2018-02-04_landlock-fosdem.pdf), especially slides 11 and 12.
Let me explain my reasoning about this program chaining thing.
To check if an action on a file is allowed, we first need to identify this file and match it to the security policy. In a previous (non-public) patch series, I tried to use one type of eBPF program to check every kind of access to a file. To be able to identify a file, I relied on an eBPF map, similar to the current inode map. This map store a set of references to file descriptors. I then created a function bpf_is_file_beneath() to check if the requested file was beneath a file in the map. This way, no chaining, only one eBPF program type to check an access to a file... but some issues then emerged. First, this design create a side-channel which help an attacker using such a program to infer some information not normally available, for example to get a hint on where a file descriptor (received from a UNIX socket) come from. Another issue is that this type of program would be called for each component of a path. Indeed, when the kernel check if an access to a file is allowed, it walk through all of the directories in its path (checking if the current process is allowed to execute them). That first attempt led me to rethink the way we could filter an access to a file *path*.
To minimize the number of called to an eBPF program dedicated to validate an access to a file path, I decided to create three subtype of eBPF programs. The FS_WALK type is called when walking through every directory of a file path (except the last one if it is the target). We can then restrict this type of program to the minimum set of functions it is allowed to call and the minimum set of data available from its context. The first implicit chaining is for this type of program. To be able to evaluate a path while being called for all its components, this program need to store a state (to remember what was the parent directory of this path). There is no "previous" field in the subtype for this program because it is chained with itself, for each directories. This enable to create a FS_WALK program to evaluate a file hierarchy, thank to the inode map which can be used to check if a directory of this hierarchy is part of an allowed (or denied) list of directories. This design enables to express a file hierarchy in a programmatic way, without requiring an eBPF helper to do the job (unlike my first experiment).
The explicit chaining is used to tied a path evaluation (with a FS_WALK program) to an access to the actual file being requested (the last component of a file path), with a FS_PICK program. It is only at this time that the kernel check for the requested action (e.g. read, write, chdir, append...). To be able to filter such access request we can have one call to the same program for every action and let this program check for which action it was called. However, this design does not allow the kernel to know if the current action is indeed handled by this program. Hence, it is not possible to implement a cache mechanism to only call this program if it knows how to handle this action.
The approach I took for this FS_PICK type of program is to add to its subtype which action it can handle (with the "triggers" bitfield, seen as ORed actions). This way, the kernel knows if a call to a FS_PICK program is necessary. If the user wants to enforce a different security policy according to the action requested on a file, then it needs multiple FS_PICK programs. However, to reduce the number of such programs, this patch series allow a FS_PICK program to be chained with another, the same way a FS_WALK is chained with itself. This way, if the user want to check if the action is a for example an "open" and a "read" and not a "map" and a "read", then it can chain multiple FS_PICK programs with different triggers actions. The OR check performed by the kernel is not a limitation then, only a way to know if a call to an eBPF program is needed.
The last type of program is FS_GET. This one is called when a process get a struct file or change its working directory. This is the only program type able (and allowed) to tag a file. This restriction is important to not being subject to resource exhaustion attacks (i.e. tagging every inode accessible to an attacker, which would allocate too much kernel memory).
This design gives room for improvements to create a cache of eBPF context (input data, including maps if any), with the result of an eBPF program. This would help limit the number of call to an eBPF program the same way SELinux or other kernel components do to limit costly checks.
The eBPF maps of progs are useful to call the same type of eBPF program. It does not fit with this use case because we may want multiple eBPF program according to the action requested on a kernel object (e.g. FS_GET). The other reason is because the eBPF program does not know what will be the next (type of) access check performed by the kernel.
To say it another way, this chaining mechanism is a way to split a kernel object evaluation with multiple specialized programs, each of them being able to deal with data tied to their type. Using a monolithic eBPF program to check everything does not scale and does not fit with unprivileged use either.
As a side note, the cookie value is only an ephemeral value to keep a state between multiple programs call. It can be used to create a state machine for an object evaluation.
I don't see a way to do an efficient and programmatic path evaluation, with different access checks, with the current eBPF features. Please let me know if you know how to do it another way.
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 322 lines · Mickaël Salaün
Quoted 175 lines · Andy Lutomirski
Quoted 173 lines · Alexei Starovoitov
Quoted 171 lines · Andy Lutomirski
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
(quoted diff) +105
-0+struct landlock_prog_set *landlock_prepend_prog( + struct landlock_prog_set *current_prog_set, + struct bpf_prog *prog) +{ + struct landlock_prog_set *new_prog_set = current_prog_set; + unsigned long pages; + int err; + size_t i; + struct landlock_prog_set tmp_prog_set = {}; + + if (prog->type != BPF_PROG_TYPE_LANDLOCK_HOOK) + return ERR_PTR(-EINVAL); + + /* validate memory size allocation */ + pages = prog->pages; + if (current_prog_set) { + size_t i; + + for (i = 0; i < ARRAY_SIZE(current_prog_set->programs); i++) { + struct landlock_prog_list *walker_p; + + for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } + /* count a struct landlock_prog_set if we need to allocate one */ + if (refcount_read(¤t_prog_set->usage) != 1) + pages += round_up(sizeof(*current_prog_set), PAGE_SIZE) + / PAGE_SIZE; + } + if (pages > LANDLOCK_PROGRAMS_MAX_PAGES) + return ERR_PTR(-E2BIG); + + /* ensure early that we can allocate enough memory for the new + * prog_lists */ + err = store_landlock_prog(&tmp_prog_set, current_prog_set, prog); + if (err) + return ERR_PTR(err); + + /* + * Each task_struct points to an array of prog list pointers. These + * tables are duplicated when additions are made (which means each + * table needs to be refcounted for the processes using it). When a new + * table is created, all the refcounters on the prog_list are bumped (to + * track each table that references the prog). When a new prog is + * added, it's just prepended to the list for the new table to point + * at. + * + * Manage all the possible errors before this step to not uselessly + * duplicate current_prog_set and avoid a rollback. + */ + if (!new_prog_set) { + /* + * If there is no Landlock program set used by the current task, + * then create a new one. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + } else if (refcount_read(¤t_prog_set->usage) > 1) { + /* + * If the current task is not the sole user of its Landlock + * program set, then duplicate them. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + for (i = 0; i < ARRAY_SIZE(new_prog_set->programs); i++) { + new_prog_set->programs[i] = + READ_ONCE(current_prog_set->programs[i]); + if (new_prog_set->programs[i]) + refcount_inc(&new_prog_set->programs[i]->usage); + } + + /* + * Landlock program set from the current task will not be freed + * here because the usage is strictly greater than 1. It is + * only prevented to be freed by another task thanks to the + * caller of landlock_prepend_prog() which should be locked if + * needed. + */ + landlock_put_prog_set(current_prog_set); + } + + /* prepend tmp_prog_set to new_prog_set */ + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) { + /* get the last new list */ + struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + + if (last_list) { + while (last_list->prev) + last_list = last_list->prev; + /* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; + return new_prog_set; + +put_tmp_lists: + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) + put_landlock_prog_list(tmp_prog_set.programs[i]); + return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
Quoted 8 lines
Quoted 3 lines
+1
if that was the case...
but that's not my reading of the patch set.An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.Nothing was wrong about about that, this part did not changed (see my next comment).
Quoted 5 lines
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.See Casey's answer and his patch series: https://lwn.net/Articles/741963/
Quoted 16 lines
Quoted 9 lines
Quoted 8 lines
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage acrossfork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.Quoted 6 lines
+1
in cgroup we had to invent this newBPF_PROG_RUN_ARRAYmechanism, since cgroup hierarchy can be complicated with bpf progs attached at different levels with different override/multiprog properties, so walking link list and checking all flags at run-time would have been too slow. That's why we addedcompute_effective_progs().Quoted 6 lines
If we start adding override flags to Landlock, I think we're doing it
wrong. With cgroup bpf programs, the whole mess is set up by the
administrator. With seccomp, and with Landlock if done correctly, it *won't* be set up by the administrator, so the chance that everyone gets all the flags right is about zero. All attached filters should run unconditionally.There is a misunderstanding about this chaining mechanism. This should not be confused with the list of seccomp filters nor the cgroup hierarchies. Landlock programs can be stacked the same way seccomp's filters can (cf. struct
landlock_prog_set, the "chain_last" field is an optimization which is not used for this struct handling). This stackable property did not changed from the previous patch series. The chaining mechanism is for another use case, which does not make sense for seccomp filters nor other eBPF program types, at least for now, from what I can tell.You may want to get a look at my talk at FOSDEM
(https://landlock.io/talks/2018-02-04_landlock-fosdem.pdf), especially slides 11 and 12.Let me explain my reasoning about this program chaining thing.
To check if an action on a file is allowed, we first need to identify this file and match it to the security policy. In a previous (non-public) patch series, I tried to use one type of eBPF program to check every kind of access to a file. To be able to identify a file, I relied on an eBPF map, similar to the current inode map. This map store a set of references to file descriptors. I then created a function
bpf_is_file_beneath()to check if the requested file was beneath a file in the map. This way, no chaining, only one eBPF program type to check an access to a file... but some issues then emerged. First, this design create a side-channel which help an attacker using such a program to infer some information not normally available, for example to get a hint on where a file descriptor (received from a UNIX socket) come from. Another issue is that this type of program would be called for each component of a path. Indeed, when the kernel check if an access to a file is allowed, it walk through all of the directories in its path (checking if the current process is allowed to execute them). That first attempt led me to rethink the way we could filter an access to a file *path*.To minimize the number of called to an eBPF program dedicated to validate an access to a file path, I decided to create three subtype of eBPF programs. The
FS_WALKtype is called when walking through every directory of a file path (except the last one if it is the target). We can then restrict this type of program to the minimum set of functions it is allowed to call and the minimum set of data available from its context. The first implicit chaining is for this type of program. To be able to evaluate a path while being called for all its components, this program need to store a state (to remember what was the parent directory of this path). There is no "previous" field in the subtype for this program because it is chained with itself, for each directories. This enable to create aFS_WALKprogram to evaluate a file hierarchy, thank to the inode map which can be used to check if a directory of this hierarchy is part of an allowed (or denied) list of directories. This design enables to express a file hierarchy in a programmatic way, without requiring an eBPF helper to do the job (unlike my first experiment).The explicit chaining is used to tied a path evaluation (with a
FS_WALKprogram) to an access to the actual file being requested (the last component of a file path), with aFS_PICKprogram. It is only at this time that the kernel check for the requested action (e.g. read, write, chdir, append...). To be able to filter such access request we can have one call to the same program for every action and let this program check for which action it was called. However, this design does not allow the kernel to know if the current action is indeed handled by this program. Hence, it is not possible to implement a cache mechanism to only call this program if it knows how to handle this action.The approach I took for this
FS_PICKtype of program is to add to its subtype which action it can handle (with the "triggers" bitfield, seen as ORed actions). This way, the kernel knows if a call to aFS_PICKprogram is necessary. If the user wants to enforce a different security policy according to the action requested on a file, then it needs multipleFS_PICKprograms. However, to reduce the number of such programs, this patch series allow aFS_PICKprogram to be chained with another, the same way aFS_WALKis chained with itself. This way, if the user want to check if the action is a for example an "open" and a "read" and not a "map" and a "read", then it can chain multipleFS_PICKprograms with different triggers actions. The OR check performed by the kernel is not a limitation then, only a way to know if a call to an eBPF program is needed.The last type of program is
FS_GET. This one is called when a process get a struct file or change its working directory. This is the only program type able (and allowed) to tag a file. This restriction is important to not being subject to resource exhaustion attacks (i.e. tagging every inode accessible to an attacker, which would allocate too much kernel memory).This design gives room for improvements to create a cache of eBPF context (input data, including maps if any), with the result of an eBPF program. This would help limit the number of call to an eBPF program the same way SELinux or other kernel components do to limit costly checks.
The eBPF maps of progs are useful to call the same type of eBPF program. It does not fit with this use case because we may want multiple eBPF program according to the action requested on a kernel object (e.g.
FS_GET). The other reason is because the eBPF program does not know what will be the next (type of) access check performed by the kernel.To say it another way, this chaining mechanism is a way to split a kernel object evaluation with multiple specialized programs, each of them being able to deal with data tied to their type. Using a monolithic eBPF program to check everything does not scale and does not fit with unprivileged use either.
Quoted 8 lines
As a side note, the cookie value is only an ephemeral value to keep a state between multiple programs call. It can be used to create a state machine for an object evaluation.
I don't see a way to do an efficient and programmatic path evaluation, with different access checks, with the current eBPF features. Please let me know if you know how to do it another way.
Andy, Alexei, Daniel, what do you think about this Landlock program chaining and cookie?
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 328 lines · Mickaël Salaün
Quoted 326 lines · Mickaël Salaün
Quoted 175 lines · Andy Lutomirski
Quoted 173 lines · Alexei Starovoitov
Quoted 171 lines · Andy Lutomirski
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
(quoted diff) +105
-0+struct landlock_prog_set *landlock_prepend_prog( + struct landlock_prog_set *current_prog_set, + struct bpf_prog *prog) +{ + struct landlock_prog_set *new_prog_set = current_prog_set; + unsigned long pages; + int err; + size_t i; + struct landlock_prog_set tmp_prog_set = {}; + + if (prog->type != BPF_PROG_TYPE_LANDLOCK_HOOK) + return ERR_PTR(-EINVAL); + + /* validate memory size allocation */ + pages = prog->pages; + if (current_prog_set) { + size_t i; + + for (i = 0; i < ARRAY_SIZE(current_prog_set->programs); i++) { + struct landlock_prog_list *walker_p; + + for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } + /* count a struct landlock_prog_set if we need to allocate one */ + if (refcount_read(¤t_prog_set->usage) != 1) + pages += round_up(sizeof(*current_prog_set), PAGE_SIZE) + / PAGE_SIZE; + } + if (pages > LANDLOCK_PROGRAMS_MAX_PAGES) + return ERR_PTR(-E2BIG); + + /* ensure early that we can allocate enough memory for the new + * prog_lists */ + err = store_landlock_prog(&tmp_prog_set, current_prog_set, prog); + if (err) + return ERR_PTR(err); + + /* + * Each task_struct points to an array of prog list pointers. These + * tables are duplicated when additions are made (which means each + * table needs to be refcounted for the processes using it). When a new + * table is created, all the refcounters on the prog_list are bumped (to + * track each table that references the prog). When a new prog is + * added, it's just prepended to the list for the new table to point + * at. + * + * Manage all the possible errors before this step to not uselessly + * duplicate current_prog_set and avoid a rollback. + */ + if (!new_prog_set) { + /* + * If there is no Landlock program set used by the current task, + * then create a new one. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + } else if (refcount_read(¤t_prog_set->usage) > 1) { + /* + * If the current task is not the sole user of its Landlock + * program set, then duplicate them. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + for (i = 0; i < ARRAY_SIZE(new_prog_set->programs); i++) { + new_prog_set->programs[i] = + READ_ONCE(current_prog_set->programs[i]); + if (new_prog_set->programs[i]) + refcount_inc(&new_prog_set->programs[i]->usage); + } + + /* + * Landlock program set from the current task will not be freed + * here because the usage is strictly greater than 1. It is + * only prevented to be freed by another task thanks to the + * caller of landlock_prepend_prog() which should be locked if + * needed. + */ + landlock_put_prog_set(current_prog_set); + } + + /* prepend tmp_prog_set to new_prog_set */ + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) { + /* get the last new list */ + struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + + if (last_list) { + while (last_list->prev) + last_list = last_list->prev; + /* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; + return new_prog_set; + +put_tmp_lists: + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) + put_landlock_prog_list(tmp_prog_set.programs[i]); + return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
Quoted 8 lines
Quoted 3 lines
+1
if that was the case...
but that's not my reading of the patch set.An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.Nothing was wrong about about that, this part did not changed (see my next comment).
Quoted 5 lines
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.See Casey's answer and his patch series: https://lwn.net/Articles/741963/
Quoted 16 lines
Quoted 9 lines
Quoted 8 lines
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage acrossfork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.Quoted 6 lines
+1
in cgroup we had to invent this newBPF_PROG_RUN_ARRAYmechanism, since cgroup hierarchy can be complicated with bpf progs attached at different levels with different override/multiprog properties, so walking link list and checking all flags at run-time would have been too slow. That's why we addedcompute_effective_progs().Quoted 6 lines
If we start adding override flags to Landlock, I think we're doing it
wrong. With cgroup bpf programs, the whole mess is set up by the
administrator. With seccomp, and with Landlock if done correctly, it *won't* be set up by the administrator, so the chance that everyone gets all the flags right is about zero. All attached filters should run unconditionally.There is a misunderstanding about this chaining mechanism. This should not be confused with the list of seccomp filters nor the cgroup hierarchies. Landlock programs can be stacked the same way seccomp's filters can (cf. struct
landlock_prog_set, the "chain_last" field is an optimization which is not used for this struct handling). This stackable property did not changed from the previous patch series. The chaining mechanism is for another use case, which does not make sense for seccomp filters nor other eBPF program types, at least for now, from what I can tell.You may want to get a look at my talk at FOSDEM
(https://landlock.io/talks/2018-02-04_landlock-fosdem.pdf), especially slides 11 and 12.Let me explain my reasoning about this program chaining thing.
To check if an action on a file is allowed, we first need to identify this file and match it to the security policy. In a previous (non-public) patch series, I tried to use one type of eBPF program to check every kind of access to a file. To be able to identify a file, I relied on an eBPF map, similar to the current inode map. This map store a set of references to file descriptors. I then created a function
bpf_is_file_beneath()to check if the requested file was beneath a file in the map. This way, no chaining, only one eBPF program type to check an access to a file... but some issues then emerged. First, this design create a side-channel which help an attacker using such a program to infer some information not normally available, for example to get a hint on where a file descriptor (received from a UNIX socket) come from. Another issue is that this type of program would be called for each component of a path. Indeed, when the kernel check if an access to a file is allowed, it walk through all of the directories in its path (checking if the current process is allowed to execute them). That first attempt led me to rethink the way we could filter an access to a file *path*.To minimize the number of called to an eBPF program dedicated to validate an access to a file path, I decided to create three subtype of eBPF programs. The
FS_WALKtype is called when walking through every directory of a file path (except the last one if it is the target). We can then restrict this type of program to the minimum set of functions it is allowed to call and the minimum set of data available from its context. The first implicit chaining is for this type of program. To be able to evaluate a path while being called for all its components, this program need to store a state (to remember what was the parent directory of this path). There is no "previous" field in the subtype for this program because it is chained with itself, for each directories. This enable to create aFS_WALKprogram to evaluate a file hierarchy, thank to the inode map which can be used to check if a directory of this hierarchy is part of an allowed (or denied) list of directories. This design enables to express a file hierarchy in a programmatic way, without requiring an eBPF helper to do the job (unlike my first experiment).The explicit chaining is used to tied a path evaluation (with a
FS_WALKprogram) to an access to the actual file being requested (the last component of a file path), with aFS_PICKprogram. It is only at this time that the kernel check for the requested action (e.g. read, write, chdir, append...). To be able to filter such access request we can have one call to the same program for every action and let this program check for which action it was called. However, this design does not allow the kernel to know if the current action is indeed handled by this program. Hence, it is not possible to implement a cache mechanism to only call this program if it knows how to handle this action.The approach I took for this
FS_PICKtype of program is to add to its subtype which action it can handle (with the "triggers" bitfield, seen as ORed actions). This way, the kernel knows if a call to aFS_PICKprogram is necessary. If the user wants to enforce a different security policy according to the action requested on a file, then it needs multipleFS_PICKprograms. However, to reduce the number of such programs, this patch series allow aFS_PICKprogram to be chained with another, the same way aFS_WALKis chained with itself. This way, if the user want to check if the action is a for example an "open" and a "read" and not a "map" and a "read", then it can chain multipleFS_PICKprograms with different triggers actions. The OR check performed by the kernel is not a limitation then, only a way to know if a call to an eBPF program is needed.The last type of program is
FS_GET. This one is called when a process get a struct file or change its working directory. This is the only program type able (and allowed) to tag a file. This restriction is important to not being subject to resource exhaustion attacks (i.e. tagging every inode accessible to an attacker, which would allocate too much kernel memory).This design gives room for improvements to create a cache of eBPF context (input data, including maps if any), with the result of an eBPF program. This would help limit the number of call to an eBPF program the same way SELinux or other kernel components do to limit costly checks.
The eBPF maps of progs are useful to call the same type of eBPF program. It does not fit with this use case because we may want multiple eBPF program according to the action requested on a kernel object (e.g.
FS_GET). The other reason is because the eBPF program does not know what will be the next (type of) access check performed by the kernel.To say it another way, this chaining mechanism is a way to split a kernel object evaluation with multiple specialized programs, each of them being able to deal with data tied to their type. Using a monolithic eBPF program to check everything does not scale and does not fit with unprivileged use either.
As a side note, the cookie value is only an ephemeral value to keep a state between multiple programs call. It can be used to create a state machine for an object evaluation.
Quoted 8 lines
Quoted 4 lines
I don't see a way to do an efficient and programmatic path evaluation, with different access checks, with the current eBPF features. Please let me know if you know how to do it another way.
Andy, Alexei, Daniel, what do you think about this Landlock program chaining and cookie?
Can you give a small pseudocode real world example that acutally needs chaining? The mechanism is quite complicated and I'd like to understand how it'll be used.
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 334 lines · Andy Lutomirski
Quoted 333 lines · Mickaël Salaün
Quoted 330 lines · Mickaël Salaün
Quoted 175 lines · Andy Lutomirski
Quoted 173 lines · Alexei Starovoitov
Quoted 171 lines · Andy Lutomirski
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
(quoted diff) +105
-0+struct landlock_prog_set *landlock_prepend_prog( + struct landlock_prog_set *current_prog_set, + struct bpf_prog *prog) +{ + struct landlock_prog_set *new_prog_set = current_prog_set; + unsigned long pages; + int err; + size_t i; + struct landlock_prog_set tmp_prog_set = {}; + + if (prog->type != BPF_PROG_TYPE_LANDLOCK_HOOK) + return ERR_PTR(-EINVAL); + + /* validate memory size allocation */ + pages = prog->pages; + if (current_prog_set) { + size_t i; + + for (i = 0; i < ARRAY_SIZE(current_prog_set->programs); i++) { + struct landlock_prog_list *walker_p; + + for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } + /* count a struct landlock_prog_set if we need to allocate one */ + if (refcount_read(¤t_prog_set->usage) != 1) + pages += round_up(sizeof(*current_prog_set), PAGE_SIZE) + / PAGE_SIZE; + } + if (pages > LANDLOCK_PROGRAMS_MAX_PAGES) + return ERR_PTR(-E2BIG); + + /* ensure early that we can allocate enough memory for the new + * prog_lists */ + err = store_landlock_prog(&tmp_prog_set, current_prog_set, prog); + if (err) + return ERR_PTR(err); + + /* + * Each task_struct points to an array of prog list pointers. These + * tables are duplicated when additions are made (which means each + * table needs to be refcounted for the processes using it). When a new + * table is created, all the refcounters on the prog_list are bumped (to + * track each table that references the prog). When a new prog is + * added, it's just prepended to the list for the new table to point + * at. + * + * Manage all the possible errors before this step to not uselessly + * duplicate current_prog_set and avoid a rollback. + */ + if (!new_prog_set) { + /* + * If there is no Landlock program set used by the current task, + * then create a new one. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + } else if (refcount_read(¤t_prog_set->usage) > 1) { + /* + * If the current task is not the sole user of its Landlock + * program set, then duplicate them. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + for (i = 0; i < ARRAY_SIZE(new_prog_set->programs); i++) { + new_prog_set->programs[i] = + READ_ONCE(current_prog_set->programs[i]); + if (new_prog_set->programs[i]) + refcount_inc(&new_prog_set->programs[i]->usage); + } + + /* + * Landlock program set from the current task will not be freed + * here because the usage is strictly greater than 1. It is + * only prevented to be freed by another task thanks to the + * caller of landlock_prepend_prog() which should be locked if + * needed. + */ + landlock_put_prog_set(current_prog_set); + } + + /* prepend tmp_prog_set to new_prog_set */ + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) { + /* get the last new list */ + struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + + if (last_list) { + while (last_list->prev) + last_list = last_list->prev; + /* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; + return new_prog_set; + +put_tmp_lists: + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) + put_landlock_prog_list(tmp_prog_set.programs[i]); + return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
Quoted 8 lines
Quoted 3 lines
+1
if that was the case...
but that's not my reading of the patch set.An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.Nothing was wrong about about that, this part did not changed (see my next comment).
Quoted 5 lines
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.See Casey's answer and his patch series: https://lwn.net/Articles/741963/
Quoted 16 lines
Quoted 9 lines
Quoted 8 lines
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage acrossfork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.Quoted 6 lines
+1
in cgroup we had to invent this newBPF_PROG_RUN_ARRAYmechanism, since cgroup hierarchy can be complicated with bpf progs attached at different levels with different override/multiprog properties, so walking link list and checking all flags at run-time would have been too slow. That's why we addedcompute_effective_progs().Quoted 6 lines
If we start adding override flags to Landlock, I think we're doing it
wrong. With cgroup bpf programs, the whole mess is set up by the
administrator. With seccomp, and with Landlock if done correctly, it *won't* be set up by the administrator, so the chance that everyone gets all the flags right is about zero. All attached filters should run unconditionally.There is a misunderstanding about this chaining mechanism. This should not be confused with the list of seccomp filters nor the cgroup hierarchies. Landlock programs can be stacked the same way seccomp's filters can (cf. struct
landlock_prog_set, the "chain_last" field is an optimization which is not used for this struct handling). This stackable property did not changed from the previous patch series. The chaining mechanism is for another use case, which does not make sense for seccomp filters nor other eBPF program types, at least for now, from what I can tell.You may want to get a look at my talk at FOSDEM
(https://landlock.io/talks/2018-02-04_landlock-fosdem.pdf), especially slides 11 and 12.Let me explain my reasoning about this program chaining thing.
To check if an action on a file is allowed, we first need to identify this file and match it to the security policy. In a previous (non-public) patch series, I tried to use one type of eBPF program to check every kind of access to a file. To be able to identify a file, I relied on an eBPF map, similar to the current inode map. This map store a set of references to file descriptors. I then created a function
bpf_is_file_beneath()to check if the requested file was beneath a file in the map. This way, no chaining, only one eBPF program type to check an access to a file... but some issues then emerged. First, this design create a side-channel which help an attacker using such a program to infer some information not normally available, for example to get a hint on where a file descriptor (received from a UNIX socket) come from. Another issue is that this type of program would be called for each component of a path. Indeed, when the kernel check if an access to a file is allowed, it walk through all of the directories in its path (checking if the current process is allowed to execute them). That first attempt led me to rethink the way we could filter an access to a file *path*.To minimize the number of called to an eBPF program dedicated to validate an access to a file path, I decided to create three subtype of eBPF programs. The
FS_WALKtype is called when walking through every directory of a file path (except the last one if it is the target). We can then restrict this type of program to the minimum set of functions it is allowed to call and the minimum set of data available from its context. The first implicit chaining is for this type of program. To be able to evaluate a path while being called for all its components, this program need to store a state (to remember what was the parent directory of this path). There is no "previous" field in the subtype for this program because it is chained with itself, for each directories. This enable to create aFS_WALKprogram to evaluate a file hierarchy, thank to the inode map which can be used to check if a directory of this hierarchy is part of an allowed (or denied) list of directories. This design enables to express a file hierarchy in a programmatic way, without requiring an eBPF helper to do the job (unlike my first experiment).The explicit chaining is used to tied a path evaluation (with a
FS_WALKprogram) to an access to the actual file being requested (the last component of a file path), with aFS_PICKprogram. It is only at this time that the kernel check for the requested action (e.g. read, write, chdir, append...). To be able to filter such access request we can have one call to the same program for every action and let this program check for which action it was called. However, this design does not allow the kernel to know if the current action is indeed handled by this program. Hence, it is not possible to implement a cache mechanism to only call this program if it knows how to handle this action.The approach I took for this
FS_PICKtype of program is to add to its subtype which action it can handle (with the "triggers" bitfield, seen as ORed actions). This way, the kernel knows if a call to aFS_PICKprogram is necessary. If the user wants to enforce a different security policy according to the action requested on a file, then it needs multipleFS_PICKprograms. However, to reduce the number of such programs, this patch series allow aFS_PICKprogram to be chained with another, the same way aFS_WALKis chained with itself. This way, if the user want to check if the action is a for example an "open" and a "read" and not a "map" and a "read", then it can chain multipleFS_PICKprograms with different triggers actions. The OR check performed by the kernel is not a limitation then, only a way to know if a call to an eBPF program is needed.The last type of program is
FS_GET. This one is called when a process get a struct file or change its working directory. This is the only program type able (and allowed) to tag a file. This restriction is important to not being subject to resource exhaustion attacks (i.e. tagging every inode accessible to an attacker, which would allocate too much kernel memory).This design gives room for improvements to create a cache of eBPF context (input data, including maps if any), with the result of an eBPF program. This would help limit the number of call to an eBPF program the same way SELinux or other kernel components do to limit costly checks.
The eBPF maps of progs are useful to call the same type of eBPF program. It does not fit with this use case because we may want multiple eBPF program according to the action requested on a kernel object (e.g.
FS_GET). The other reason is because the eBPF program does not know what will be the next (type of) access check performed by the kernel.To say it another way, this chaining mechanism is a way to split a kernel object evaluation with multiple specialized programs, each of them being able to deal with data tied to their type. Using a monolithic eBPF program to check everything does not scale and does not fit with unprivileged use either.
As a side note, the cookie value is only an ephemeral value to keep a state between multiple programs call. It can be used to create a state machine for an object evaluation.
I don't see a way to do an efficient and programmatic path evaluation, with different access checks, with the current eBPF features. Please let me know if you know how to do it another way.
Quoted 8 lines
Quoted 3 lines
Andy, Alexei, Daniel, what do you think about this Landlock program chaining and cookie?
Can you give a small pseudocode real world example that acutally needs chaining? The mechanism is quite complicated and I'd like to understand how it'll be used.
Here is the interesting part from the example (patch 09/11):
+SEC("maps")
+struct bpf_map_def inode_map = {
+ .type = BPF_MAP_TYPE_INODE,
+ .key_size = sizeof(u32),
+ .value_size = sizeof(u64),
+ .max_entries = 20,
+};
+
+SEC("subtype/landlock1")
+static union bpf_prog_subtype _subtype1 = {
+ .landlock_hook = {
+ .type = LANDLOCK_HOOK_FS_WALK,
+ }
+};
+
+static __always_inline __u64 update_cookie(__u64 cookie, __u8 lookup,
+ void *inode, void *chain, bool freeze)
+{
+ __u64 map_allow = 0;
+
+ if (cookie == 0) {
+ cookie = bpf_inode_get_tag(inode, chain);
+ if (cookie)
+ return cookie;
+ /* only look for the first match in the map, ignore nested
+ * paths in this example */
+ map_allow = bpf_inode_map_lookup(&inode_map, inode);
+ if (map_allow)
+ cookie = 1 | map_allow;
+ } else {
+ if (cookie & COOKIE_VALUE_FREEZED)
+ return cookie;
+ map_allow = cookie & _MAP_MARK_MASK;
+ cookie &= ~_MAP_MARK_MASK;
+ switch (lookup) {
+ case LANDLOCK_CTX_FS_WALK_INODE_LOOKUP_DOTDOT:
+ cookie--;
+ break;
+ case LANDLOCK_CTX_FS_WALK_INODE_LOOKUP_DOT:
+ break;
+ default:
+ /* ignore _MAP_MARK_MASK overflow in this example */
+ cookie++;
+ break;
+ }
+ if (cookie >= 1)
+ cookie |= map_allow;
+ }
+ /* do not modify the cookie for each fs_pick */
+ if (freeze && cookie)
+ cookie |= COOKIE_VALUE_FREEZED;
+ return cookie;
+}
+
+SEC("landlock1")
+int fs_walk(struct landlock_ctx_fs_walk *ctx)
+{
+ ctx->cookie = update_cookie(ctx->cookie, ctx->inode_lookup,
+ (void *)ctx->inode, (void *)ctx->chain, false);
+ return LANDLOCK_RET_ALLOW;
+}
The program "landlock1" is called for every directory execution (except the last one if it is the leaf of a path). This enables to identify a file hierarchy with only a (one dimension) list of file descriptors (i.e. inode_map).
Underneath, the Landlock LSM part looks if there is an associated path walk (nameidata) with each inode access request. If there is one, then the cookie associated with the path walk (if any) is made available through the eBPF program context. This enables to develop a state machine with an eBPF program to "evaluate" a file path (without string parsing).
The goal with this chaining mechanism is to be able to express a complex kernel object like a file, with multiple run of one or more eBPF programs, as a multilayer evaluation. This semantic may only make sense for the user/developer and his security policy. We must keep in mind that this object identification should be available to unprivileged processes. This means that we must be very careful to what kind of information are available to an eBPF program because this can then leak to a process (e.g. through a map). With this mechanism, only information already available to user space is available to the eBPF program.
In this example, the complexity of the path evaluation is in the eBPF program. We can then keep the kernel code more simple and generic. This enables more flexibility for a security policy definition.
Re: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 431 lines · Mickaël Salaün
Quoted 334 lines · Andy Lutomirski
Quoted 333 lines · Mickaël Salaün
Quoted 330 lines · Mickaël Salaün
Quoted 175 lines · Andy Lutomirski
Quoted 173 lines · Alexei Starovoitov
Quoted 171 lines · Andy Lutomirski
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
(quoted diff) +105
-0+struct landlock_prog_set *landlock_prepend_prog( + struct landlock_prog_set *current_prog_set, + struct bpf_prog *prog) +{ + struct landlock_prog_set *new_prog_set = current_prog_set; + unsigned long pages; + int err; + size_t i; + struct landlock_prog_set tmp_prog_set = {}; + + if (prog->type != BPF_PROG_TYPE_LANDLOCK_HOOK) + return ERR_PTR(-EINVAL); + + /* validate memory size allocation */ + pages = prog->pages; + if (current_prog_set) { + size_t i; + + for (i = 0; i < ARRAY_SIZE(current_prog_set->programs); i++) { + struct landlock_prog_list *walker_p; + + for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } + /* count a struct landlock_prog_set if we need to allocate one */ + if (refcount_read(¤t_prog_set->usage) != 1) + pages += round_up(sizeof(*current_prog_set), PAGE_SIZE) + / PAGE_SIZE; + } + if (pages > LANDLOCK_PROGRAMS_MAX_PAGES) + return ERR_PTR(-E2BIG); + + /* ensure early that we can allocate enough memory for the new + * prog_lists */ + err = store_landlock_prog(&tmp_prog_set, current_prog_set, prog); + if (err) + return ERR_PTR(err); + + /* + * Each task_struct points to an array of prog list pointers. These + * tables are duplicated when additions are made (which means each + * table needs to be refcounted for the processes using it). When a new + * table is created, all the refcounters on the prog_list are bumped (to + * track each table that references the prog). When a new prog is + * added, it's just prepended to the list for the new table to point + * at. + * + * Manage all the possible errors before this step to not uselessly + * duplicate current_prog_set and avoid a rollback. + */ + if (!new_prog_set) { + /* + * If there is no Landlock program set used by the current task, + * then create a new one. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + } else if (refcount_read(¤t_prog_set->usage) > 1) { + /* + * If the current task is not the sole user of its Landlock + * program set, then duplicate them. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + for (i = 0; i < ARRAY_SIZE(new_prog_set->programs); i++) { + new_prog_set->programs[i] = + READ_ONCE(current_prog_set->programs[i]); + if (new_prog_set->programs[i]) + refcount_inc(&new_prog_set->programs[i]->usage); + } + + /* + * Landlock program set from the current task will not be freed + * here because the usage is strictly greater than 1. It is + * only prevented to be freed by another task thanks to the + * caller of landlock_prepend_prog() which should be locked if + * needed. + */ + landlock_put_prog_set(current_prog_set); + } + + /* prepend tmp_prog_set to new_prog_set */ + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) { + /* get the last new list */ + struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + + if (last_list) { + while (last_list->prev) + last_list = last_list->prev; + /* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; + return new_prog_set; + +put_tmp_lists: + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) + put_landlock_prog_list(tmp_prog_set.programs[i]); + return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
Quoted 8 lines
Quoted 3 lines
+1
if that was the case...
but that's not my reading of the patch set.An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.Nothing was wrong about about that, this part did not changed (see my next comment).
Quoted 5 lines
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.See Casey's answer and his patch series: https://lwn.net/Articles/741963/
Quoted 16 lines
Quoted 9 lines
Quoted 8 lines
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage acrossfork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.Quoted 6 lines
+1
in cgroup we had to invent this newBPF_PROG_RUN_ARRAYmechanism, since cgroup hierarchy can be complicated with bpf progs attached at different levels with different override/multiprog properties, so walking link list and checking all flags at run-time would have been too slow. That's why we addedcompute_effective_progs().Quoted 6 lines
If we start adding override flags to Landlock, I think we're doing it
wrong. With cgroup bpf programs, the whole mess is set up by the
administrator. With seccomp, and with Landlock if done correctly, it *won't* be set up by the administrator, so the chance that everyone gets all the flags right is about zero. All attached filters should run unconditionally.There is a misunderstanding about this chaining mechanism. This should not be confused with the list of seccomp filters nor the cgroup hierarchies. Landlock programs can be stacked the same way seccomp's filters can (cf. struct
landlock_prog_set, the "chain_last" field is an optimization which is not used for this struct handling). This stackable property did not changed from the previous patch series. The chaining mechanism is for another use case, which does not make sense for seccomp filters nor other eBPF program types, at least for now, from what I can tell.You may want to get a look at my talk at FOSDEM
(https://landlock.io/talks/2018-02-04_landlock-fosdem.pdf), especially slides 11 and 12.Let me explain my reasoning about this program chaining thing.
To check if an action on a file is allowed, we first need to identify this file and match it to the security policy. In a previous (non-public) patch series, I tried to use one type of eBPF program to check every kind of access to a file. To be able to identify a file, I relied on an eBPF map, similar to the current inode map. This map store a set of references to file descriptors. I then created a function
bpf_is_file_beneath()to check if the requested file was beneath a file in the map. This way, no chaining, only one eBPF program type to check an access to a file... but some issues then emerged. First, this design create a side-channel which help an attacker using such a program to infer some information not normally available, for example to get a hint on where a file descriptor (received from a UNIX socket) come from. Another issue is that this type of program would be called for each component of a path. Indeed, when the kernel check if an access to a file is allowed, it walk through all of the directories in its path (checking if the current process is allowed to execute them). That first attempt led me to rethink the way we could filter an access to a file *path*.To minimize the number of called to an eBPF program dedicated to validate an access to a file path, I decided to create three subtype of eBPF programs. The
FS_WALKtype is called when walking through every directory of a file path (except the last one if it is the target). We can then restrict this type of program to the minimum set of functions it is allowed to call and the minimum set of data available from its context. The first implicit chaining is for this type of program. To be able to evaluate a path while being called for all its components, this program need to store a state (to remember what was the parent directory of this path). There is no "previous" field in the subtype for this program because it is chained with itself, for each directories. This enable to create aFS_WALKprogram to evaluate a file hierarchy, thank to the inode map which can be used to check if a directory of this hierarchy is part of an allowed (or denied) list of directories. This design enables to express a file hierarchy in a programmatic way, without requiring an eBPF helper to do the job (unlike my first experiment).The explicit chaining is used to tied a path evaluation (with a
FS_WALKprogram) to an access to the actual file being requested (the last component of a file path), with aFS_PICKprogram. It is only at this time that the kernel check for the requested action (e.g. read, write, chdir, append...). To be able to filter such access request we can have one call to the same program for every action and let this program check for which action it was called. However, this design does not allow the kernel to know if the current action is indeed handled by this program. Hence, it is not possible to implement a cache mechanism to only call this program if it knows how to handle this action.The approach I took for this
FS_PICKtype of program is to add to its subtype which action it can handle (with the "triggers" bitfield, seen as ORed actions). This way, the kernel knows if a call to aFS_PICKprogram is necessary. If the user wants to enforce a different security policy according to the action requested on a file, then it needs multipleFS_PICKprograms. However, to reduce the number of such programs, this patch series allow aFS_PICKprogram to be chained with another, the same way aFS_WALKis chained with itself. This way, if the user want to check if the action is a for example an "open" and a "read" and not a "map" and a "read", then it can chain multipleFS_PICKprograms with different triggers actions. The OR check performed by the kernel is not a limitation then, only a way to know if a call to an eBPF program is needed.The last type of program is
FS_GET. This one is called when a process get a struct file or change its working directory. This is the only program type able (and allowed) to tag a file. This restriction is important to not being subject to resource exhaustion attacks (i.e. tagging every inode accessible to an attacker, which would allocate too much kernel memory).This design gives room for improvements to create a cache of eBPF context (input data, including maps if any), with the result of an eBPF program. This would help limit the number of call to an eBPF program the same way SELinux or other kernel components do to limit costly checks.
The eBPF maps of progs are useful to call the same type of eBPF program. It does not fit with this use case because we may want multiple eBPF program according to the action requested on a kernel object (e.g.
FS_GET). The other reason is because the eBPF program does not know what will be the next (type of) access check performed by the kernel.To say it another way, this chaining mechanism is a way to split a kernel object evaluation with multiple specialized programs, each of them being able to deal with data tied to their type. Using a monolithic eBPF program to check everything does not scale and does not fit with unprivileged use either.
As a side note, the cookie value is only an ephemeral value to keep a state between multiple programs call. It can be used to create a state machine for an object evaluation.
I don't see a way to do an efficient and programmatic path evaluation, with different access checks, with the current eBPF features. Please let me know if you know how to do it another way.
Quoted 8 lines
Quoted 3 lines
Andy, Alexei, Daniel, what do you think about this Landlock program chaining and cookie?
Can you give a small pseudocode real world example that acutally needs chaining? The mechanism is quite complicated and I'd like to understand how it'll be used.
Here is the interesting part from the example (patch 09/11):
(quoted diff) +61
-0+SEC("maps") +struct bpf_map_def inode_map = { + .type = BPF_MAP_TYPE_INODE, + .key_size = sizeof(u32), + .value_size = sizeof(u64), + .max_entries = 20, +}; + +SEC("subtype/landlock1") +static union bpf_prog_subtype _subtype1 = { + .landlock_hook = { + .type = LANDLOCK_HOOK_FS_WALK, + } +}; + +static __always_inline __u64 update_cookie(__u64 cookie, __u8 lookup, + void *inode, void *chain, bool freeze) +{ + __u64 map_allow = 0; + + if (cookie == 0) { + cookie = bpf_inode_get_tag(inode, chain); + if (cookie) + return cookie; + /* only look for the first match in the map, ignore nested + * paths in this example */ + map_allow = bpf_inode_map_lookup(&inode_map, inode); + if (map_allow) + cookie = 1 | map_allow; + } else { + if (cookie & COOKIE_VALUE_FREEZED) + return cookie; + map_allow = cookie & _MAP_MARK_MASK; + cookie &= ~_MAP_MARK_MASK; + switch (lookup) { + case LANDLOCK_CTX_FS_WALK_INODE_LOOKUP_DOTDOT: + cookie--; + break; + case LANDLOCK_CTX_FS_WALK_INODE_LOOKUP_DOT: + break; + default: + /* ignore _MAP_MARK_MASK overflow in this example */ + cookie++; + break; + } + if (cookie >= 1) + cookie |= map_allow; + } + /* do not modify the cookie for each fs_pick */ + if (freeze && cookie) + cookie |= COOKIE_VALUE_FREEZED; + return cookie; +} + +SEC("landlock1") +int fs_walk(struct landlock_ctx_fs_walk *ctx) +{ + ctx->cookie = update_cookie(ctx->cookie, ctx->inode_lookup, + (void *)ctx->inode, (void *)ctx->chain, false); + return LANDLOCK_RET_ALLOW; +}The program "landlock1" is called for every directory execution (except the last one if it is the leaf of a path). This enables to identify a file hierarchy with only a (one dimension) list of file descriptors (i.e.
inode_map).Underneath, the Landlock LSM part looks if there is an associated path walk (nameidata) with each inode access request. If there is one, then the cookie associated with the path walk (if any) is made available through the eBPF program context. This enables to develop a state machine with an eBPF program to "evaluate" a file path (without string parsing).
The goal with this chaining mechanism is to be able to express a complex kernel object like a file, with multiple run of one or more eBPF programs, as a multilayer evaluation. This semantic may only make sense for the user/developer and his security policy. We must keep in mind that this object identification should be available to unprivileged processes. This means that we must be very careful to what kind of information are available to an eBPF program because this can then leak to a process (e.g. through a map). With this mechanism, only information already available to user space is available to the eBPF program.
Quoted 3 lines
In this example, the complexity of the path evaluation is in the eBPF program. We can then keep the kernel code more simple and generic. This enables more flexibility for a security policy definition.
it all sounds correct on paper, but it's pretty novel approach and I'm not sure I see all the details in the patch. When people say "inode" they most of the time mean inode integer number, whereas in this patch do you mean a raw pointer to in-kernel 'struct inode' ?
To avoid confusion it should probably be called differently.
If you meant inode as a number then why inode only? where is superblock, device, mount point?
How bpf side can compare inodes without this additional info? How bpf side will know what inode to compare to? What if inode number is reused?
This approach is an optimization to compare inodes instead of strings passed into sys_open ?
If you meant inode as a pointer how bpf side will
know the pointer before the walk begins?
What guarantees that it's not a stale pointer?
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 05/11] seccomp,landlock: Enforce Landlock programs per process hierarchy
Quoted 432 lines · Alexei Starovoitov
Quoted 431 lines · Mickaël Salaün
Quoted 334 lines · Andy Lutomirski
Quoted 333 lines · Mickaël Salaün
Quoted 330 lines · Mickaël Salaün
Quoted 175 lines · Andy Lutomirski
Quoted 173 lines · Alexei Starovoitov
Quoted 171 lines · Andy Lutomirski
Quoted 155 lines · Alexei Starovoitov
Quoted 154 lines · Andy Lutomirski
Quoted 137 lines · Alexei Starovoitov
Quoted 28 lines · Mickaël Salaün
The seccomp(2) syscall can be used by a task to apply a Landlock program to itself. As a seccomp filter, a Landlock program is enforced for the current task and all its future children. A program is immutable and a task can only add new restricting programs to itself, forming a list of programss.
A Landlock program is tied to a Landlock hook. If the action on a kernel object is allowed by the other Linux security mechanisms (e.g. DAC, capabilities, other LSM), then a Landlock hook related to this kind of object is triggered. The list of programs for this hook is then evaluated. Each program return a 32-bit value which can deny the action on a kernel object with a non-zero value. If every programs of the list return zero, then the action on the object is allowed.
Multiple Landlock programs can be chained to share a 64-bits value for a call chain (e.g. evaluating multiple elements of a file path). This chaining is restricted when a process construct this chain by loading a program, but additional checks are performed when it requests to apply this chain of programs to itself. The restrictions ensure that it is not possible to call multiple programs in a way that would imply to handle multiple shared values (i.e. cookies) for one chain. For now, only a
fs_pickprogram can be chained to the same type of program, because it may make sense if they have different triggers (cf. next commits). This restrictions still allows to reuse Landlock programs in a safe way (e.g. use the same loadedfs_walkprogram with multiple chains offs_pickprograms).Signed-off-by Mickaël Salaün <[email protected]>...
Quoted 105 lines
(quoted diff) +105
-0+struct landlock_prog_set *landlock_prepend_prog( + struct landlock_prog_set *current_prog_set, + struct bpf_prog *prog) +{ + struct landlock_prog_set *new_prog_set = current_prog_set; + unsigned long pages; + int err; + size_t i; + struct landlock_prog_set tmp_prog_set = {}; + + if (prog->type != BPF_PROG_TYPE_LANDLOCK_HOOK) + return ERR_PTR(-EINVAL); + + /* validate memory size allocation */ + pages = prog->pages; + if (current_prog_set) { + size_t i; + + for (i = 0; i < ARRAY_SIZE(current_prog_set->programs); i++) { + struct landlock_prog_list *walker_p; + + for (walker_p = current_prog_set->programs[i]; + walker_p; walker_p = walker_p->prev) + pages += walker_p->prog->pages; + } + /* count a struct landlock_prog_set if we need to allocate one */ + if (refcount_read(¤t_prog_set->usage) != 1) + pages += round_up(sizeof(*current_prog_set), PAGE_SIZE) + / PAGE_SIZE; + } + if (pages > LANDLOCK_PROGRAMS_MAX_PAGES) + return ERR_PTR(-E2BIG); + + /* ensure early that we can allocate enough memory for the new + * prog_lists */ + err = store_landlock_prog(&tmp_prog_set, current_prog_set, prog); + if (err) + return ERR_PTR(err); + + /* + * Each task_struct points to an array of prog list pointers. These + * tables are duplicated when additions are made (which means each + * table needs to be refcounted for the processes using it). When a new + * table is created, all the refcounters on the prog_list are bumped (to + * track each table that references the prog). When a new prog is + * added, it's just prepended to the list for the new table to point + * at. + * + * Manage all the possible errors before this step to not uselessly + * duplicate current_prog_set and avoid a rollback. + */ + if (!new_prog_set) { + /* + * If there is no Landlock program set used by the current task, + * then create a new one. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + } else if (refcount_read(¤t_prog_set->usage) > 1) { + /* + * If the current task is not the sole user of its Landlock + * program set, then duplicate them. + */ + new_prog_set = new_landlock_prog_set(); + if (IS_ERR(new_prog_set)) + goto put_tmp_lists; + for (i = 0; i < ARRAY_SIZE(new_prog_set->programs); i++) { + new_prog_set->programs[i] = + READ_ONCE(current_prog_set->programs[i]); + if (new_prog_set->programs[i]) + refcount_inc(&new_prog_set->programs[i]->usage); + } + + /* + * Landlock program set from the current task will not be freed + * here because the usage is strictly greater than 1. It is + * only prevented to be freed by another task thanks to the + * caller of landlock_prepend_prog() which should be locked if + * needed. + */ + landlock_put_prog_set(current_prog_set); + } + + /* prepend tmp_prog_set to new_prog_set */ + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) { + /* get the last new list */ + struct landlock_prog_list *last_list = + tmp_prog_set.programs[i]; + + if (last_list) { + while (last_list->prev) + last_list = last_list->prev; + /* no need to increment usage (pointer replacement) */ + last_list->prev = new_prog_set->programs[i]; + new_prog_set->programs[i] = tmp_prog_set.programs[i]; + } + } + new_prog_set->chain_last = tmp_prog_set.chain_last; + return new_prog_set; + +put_tmp_lists: + for (i = 0; i < ARRAY_SIZE(tmp_prog_set.programs); i++) + put_landlock_prog_list(tmp_prog_set.programs[i]); + return new_prog_set;Quoted 9 lines
Quoted 1 line
+}
Nack on the chaining concept.
Please do not reinvent the wheel.
There is an existing mechanism for attaching/detaching/quering multiple programs attached to cgroup and tracing hooks that are also efficiently executed viaBPF_PROG_RUN_ARRAY.
Please use that instead.I don't see how that would help. Suppose you add a filter, then
fork(), and then the child adds another filter. Do you want to duplicate the entire array? You certainly can't *modify* the array because you'll affect processes that shouldn't be affected.Quoted 8 lines
Quoted 2 lines
In contrast, doing this through seccomp like the earlier patches seemed just fine to me, and seccomp already had the right logic.
it doesn't look to me that existing seccomp side of managing fork situation can be reused. Here there is an attempt to add 'chaining' concept which sort of an extension of existing seccomp style, but somehow heavily done on bpf side and contradicts cgroup/tracing.
I don't see why the seccomp way can't be used. I agree with you that the seccomp *style* shouldn't be used in bpf code like this, but I think that Landlock programs can and should just live in the existing seccomp chain. If the existing seccomp code needs some modification to make this work, then so be it.
Quoted 8 lines
Quoted 3 lines
+1
if that was the case...
but that's not my reading of the patch set.An earlier version of the patch set used the seccomp filter chain. Mickaël, what exactly was wrong with that approach other than that the
seccomp()syscall was awkward for you to use? You could add aseccomp_add_landlock_rule()syscall if you needed to.Nothing was wrong about about that, this part did not changed (see my next comment).
Quoted 5 lines
As a side comment, why is this an LSM at all, let alone a non-stacking LSM? It would make a lot more sense to me to make Landlock depend on having LSMs configured in but to call the landlock hooks directly from the
security_xyz()hooks.See Casey's answer and his patch series: https://lwn.net/Articles/741963/
Quoted 16 lines
Quoted 9 lines
Quoted 8 lines
In other words, the kernel already has two kinds of chaining:
seccomp's and bpf's. bpf's doesn't work right for this type of usage acrossfork(), whereas seccomp's already handles that case correctly. (In contrast, seccomp's is totally wrong for cgroup-attached filters.)
So IMO Landlock should use the seccomp core code and call into bpf
for the actual filtering.Quoted 6 lines
+1
in cgroup we had to invent this newBPF_PROG_RUN_ARRAYmechanism, since cgroup hierarchy can be complicated with bpf progs attached at different levels with different override/multiprog properties, so walking link list and checking all flags at run-time would have been too slow. That's why we addedcompute_effective_progs().Quoted 6 lines
If we start adding override flags to Landlock, I think we're doing it
wrong. With cgroup bpf programs, the whole mess is set up by the
administrator. With seccomp, and with Landlock if done correctly, it *won't* be set up by the administrator, so the chance that everyone gets all the flags right is about zero. All attached filters should run unconditionally.There is a misunderstanding about this chaining mechanism. This should not be confused with the list of seccomp filters nor the cgroup hierarchies. Landlock programs can be stacked the same way seccomp's filters can (cf. struct
landlock_prog_set, the "chain_last" field is an optimization which is not used for this struct handling). This stackable property did not changed from the previous patch series. The chaining mechanism is for another use case, which does not make sense for seccomp filters nor other eBPF program types, at least for now, from what I can tell.You may want to get a look at my talk at FOSDEM
(https://landlock.io/talks/2018-02-04_landlock-fosdem.pdf), especially slides 11 and 12.Let me explain my reasoning about this program chaining thing.
To check if an action on a file is allowed, we first need to identify this file and match it to the security policy. In a previous (non-public) patch series, I tried to use one type of eBPF program to check every kind of access to a file. To be able to identify a file, I relied on an eBPF map, similar to the current inode map. This map store a set of references to file descriptors. I then created a function
bpf_is_file_beneath()to check if the requested file was beneath a file in the map. This way, no chaining, only one eBPF program type to check an access to a file... but some issues then emerged. First, this design create a side-channel which help an attacker using such a program to infer some information not normally available, for example to get a hint on where a file descriptor (received from a UNIX socket) come from. Another issue is that this type of program would be called for each component of a path. Indeed, when the kernel check if an access to a file is allowed, it walk through all of the directories in its path (checking if the current process is allowed to execute them). That first attempt led me to rethink the way we could filter an access to a file *path*.To minimize the number of called to an eBPF program dedicated to validate an access to a file path, I decided to create three subtype of eBPF programs. The
FS_WALKtype is called when walking through every directory of a file path (except the last one if it is the target). We can then restrict this type of program to the minimum set of functions it is allowed to call and the minimum set of data available from its context. The first implicit chaining is for this type of program. To be able to evaluate a path while being called for all its components, this program need to store a state (to remember what was the parent directory of this path). There is no "previous" field in the subtype for this program because it is chained with itself, for each directories. This enable to create aFS_WALKprogram to evaluate a file hierarchy, thank to the inode map which can be used to check if a directory of this hierarchy is part of an allowed (or denied) list of directories. This design enables to express a file hierarchy in a programmatic way, without requiring an eBPF helper to do the job (unlike my first experiment).The explicit chaining is used to tied a path evaluation (with a
FS_WALKprogram) to an access to the actual file being requested (the last component of a file path), with aFS_PICKprogram. It is only at this time that the kernel check for the requested action (e.g. read, write, chdir, append...). To be able to filter such access request we can have one call to the same program for every action and let this program check for which action it was called. However, this design does not allow the kernel to know if the current action is indeed handled by this program. Hence, it is not possible to implement a cache mechanism to only call this program if it knows how to handle this action.The approach I took for this
FS_PICKtype of program is to add to its subtype which action it can handle (with the "triggers" bitfield, seen as ORed actions). This way, the kernel knows if a call to aFS_PICKprogram is necessary. If the user wants to enforce a different security policy according to the action requested on a file, then it needs multipleFS_PICKprograms. However, to reduce the number of such programs, this patch series allow aFS_PICKprogram to be chained with another, the same way aFS_WALKis chained with itself. This way, if the user want to check if the action is a for example an "open" and a "read" and not a "map" and a "read", then it can chain multipleFS_PICKprograms with different triggers actions. The OR check performed by the kernel is not a limitation then, only a way to know if a call to an eBPF program is needed.The last type of program is
FS_GET. This one is called when a process get a struct file or change its working directory. This is the only program type able (and allowed) to tag a file. This restriction is important to not being subject to resource exhaustion attacks (i.e. tagging every inode accessible to an attacker, which would allocate too much kernel memory).This design gives room for improvements to create a cache of eBPF context (input data, including maps if any), with the result of an eBPF program. This would help limit the number of call to an eBPF program the same way SELinux or other kernel components do to limit costly checks.
The eBPF maps of progs are useful to call the same type of eBPF program. It does not fit with this use case because we may want multiple eBPF program according to the action requested on a kernel object (e.g.
FS_GET). The other reason is because the eBPF program does not know what will be the next (type of) access check performed by the kernel.To say it another way, this chaining mechanism is a way to split a kernel object evaluation with multiple specialized programs, each of them being able to deal with data tied to their type. Using a monolithic eBPF program to check everything does not scale and does not fit with unprivileged use either.
As a side note, the cookie value is only an ephemeral value to keep a state between multiple programs call. It can be used to create a state machine for an object evaluation.
I don't see a way to do an efficient and programmatic path evaluation, with different access checks, with the current eBPF features. Please let me know if you know how to do it another way.
Quoted 8 lines
Quoted 3 lines
Andy, Alexei, Daniel, what do you think about this Landlock program chaining and cookie?
Can you give a small pseudocode real world example that acutally needs chaining? The mechanism is quite complicated and I'd like to understand how it'll be used.
Here is the interesting part from the example (patch 09/11):
(quoted diff) +61
-0+SEC("maps") +struct bpf_map_def inode_map = { + .type = BPF_MAP_TYPE_INODE, + .key_size = sizeof(u32), + .value_size = sizeof(u64), + .max_entries = 20, +}; + +SEC("subtype/landlock1") +static union bpf_prog_subtype _subtype1 = { + .landlock_hook = { + .type = LANDLOCK_HOOK_FS_WALK, + } +}; + +static __always_inline __u64 update_cookie(__u64 cookie, __u8 lookup, + void *inode, void *chain, bool freeze) +{ + __u64 map_allow = 0; + + if (cookie == 0) { + cookie = bpf_inode_get_tag(inode, chain); + if (cookie) + return cookie; + /* only look for the first match in the map, ignore nested + * paths in this example */ + map_allow = bpf_inode_map_lookup(&inode_map, inode); + if (map_allow) + cookie = 1 | map_allow; + } else { + if (cookie & COOKIE_VALUE_FREEZED) + return cookie; + map_allow = cookie & _MAP_MARK_MASK; + cookie &= ~_MAP_MARK_MASK; + switch (lookup) { + case LANDLOCK_CTX_FS_WALK_INODE_LOOKUP_DOTDOT: + cookie--; + break; + case LANDLOCK_CTX_FS_WALK_INODE_LOOKUP_DOT: + break; + default: + /* ignore _MAP_MARK_MASK overflow in this example */ + cookie++; + break; + } + if (cookie >= 1) + cookie |= map_allow; + } + /* do not modify the cookie for each fs_pick */ + if (freeze && cookie) + cookie |= COOKIE_VALUE_FREEZED; + return cookie; +} + +SEC("landlock1") +int fs_walk(struct landlock_ctx_fs_walk *ctx) +{ + ctx->cookie = update_cookie(ctx->cookie, ctx->inode_lookup, + (void *)ctx->inode, (void *)ctx->chain, false); + return LANDLOCK_RET_ALLOW; +}The program "landlock1" is called for every directory execution (except the last one if it is the leaf of a path). This enables to identify a file hierarchy with only a (one dimension) list of file descriptors (i.e.
inode_map).Underneath, the Landlock LSM part looks if there is an associated path walk (nameidata) with each inode access request. If there is one, then the cookie associated with the path walk (if any) is made available through the eBPF program context. This enables to develop a state machine with an eBPF program to "evaluate" a file path (without string parsing).
The goal with this chaining mechanism is to be able to express a complex kernel object like a file, with multiple run of one or more eBPF programs, as a multilayer evaluation. This semantic may only make sense for the user/developer and his security policy. We must keep in mind that this object identification should be available to unprivileged processes. This means that we must be very careful to what kind of information are available to an eBPF program because this can then leak to a process (e.g. through a map). With this mechanism, only information already available to user space is available to the eBPF program.
Quoted 10 lines
Quoted 3 lines
In this example, the complexity of the path evaluation is in the eBPF program. We can then keep the kernel code more simple and generic. This enables more flexibility for a security policy definition.
it all sounds correct on paper, but it's pretty novel approach and I'm not sure I see all the details in the patch. When people say "inode" they most of the time mean inode integer number, whereas in this patch do you mean a raw pointer to in-kernel 'struct inode' ?
To avoid confusion it should probably be called differently.
It's indeed a pointer to a "struct inode", not an inode number.
I was thinking about generalizing the BPF_MAP_TYPE_INODE by renaming it to BPF_MAP_TYPE_FD. This map type could then be used either to identify a set of inodes (pointers) or other kernel objects identifiable by a file descriptor. A "subtype" (similar to the BPF prog subtype introduced in this patch series) may be used to specialize such a map to statically identify the kind of content it may hold. We could then add more subtypes to identify sockets, devices, processes, and so on.
Quoted 6 lines
If you meant inode as a number then why inode only? where is superblock, device, mount point?
How bpf side can compare inodes without this additional info? How bpf side will know what inode to compare to? What if inode number is reused?
This pointer can identify if a giver inode is the same as one pointed by a file descriptor (or a file path).
Quoted 2 lines
This approach is an optimization to compare inodes instead of strings passed into
sys_open?
Comparing paths with strings is less efficient but it is also very error-prone. Another advantage of using file descriptors is for unprivileged processes: we can be sure that this processes are allowed to access a file referred by a file descriptor (opened file). Indeed we check (security_inode_getattr) that the process is allowed to stat an opened file. This way, a malicious process can't infer information by crafting path strings.
Quoted 3 lines
If you meant inode as a pointer how bpf side will
know the pointer before the walk begins?
The BPF map is filled by user space with file descriptors pointing to opened files. When a path walk begin, the LSM part of Landlock is notified that a process is requesting an access to the first element of the path (e.g. "/"). This first element may be part of a map or not. The BPF program can then choose if this request is legitimate or not.
Quoted 1 line
What guarantees that it's not a stale pointer?
When user space updates a map with a new file descriptor, the kernel checks if this FD is valid. If this is the case, then the inode's usage counter is incremented and its address is stored in the map.
Mickaël Salaün
maintainerPATCH v8 6/11 bpf,landlock: Add a new map type: inode
In reply to Mickaël SalaünThis new map store arbitrary 64-bits values referenced by inode keys. The map can be updated from user space with file descriptor pointing to inodes tied to a file system. From an eBPF (Landlock) program point of view, such a map is read-only and can only be used to retrieved a 64-bits value tied to a given inode. This is useful to recognize an inode tagged by user space, without access right to this inode (i.e. no need to have a write access to this inode).
This also add new BPF map object types: landlock_tag_object and landlock_chain. The landlock_chain pointer is needed to be able to handle multiple tags per inode. The landlock_tag_object is needed to update a reference to a list of shared tags. This is typically used by a struct file (reference) and a struct inode (shared list of tags). This way, we can account the process/user for the number of tagged files, while still being able to read the tags from the pointed inode.
Add dedicated BPF functions to handle this type of map:
* bpf_inode_map_update_elem()
* bpf_inode_map_lookup_elem()
* bpf_inode_map_delete_elem()
---
Changes since v7:
* new design with a dedicated map and a BPF function to tie a value to an inode
* add the ability to set or get a tag on an inode from a Landlock program
Changes since v6:
* remove WARN_ON() for missing dentry->d_inode
* refactor bpf_landlock_func_proto() (suggested by Kees Cook)
Changes since v5:
* cosmetic fixes and rebase
Changes since v4:
* use a file abstraction (handle) to wrap inode, dentry, path and file structs
* remove bpf_landlock_cmp_fs_beneath()
* rename the BPF helper and move it to kernel/bpf/
* tighten helpers accessible by a Landlock rule
Changes since v3:
* remove bpf_landlock_cmp_fs_prop() (suggested by Alexei Starovoitov)
* add hooks dealing with struct inode and struct path pointers:
inode_permission and inode_getattr
* add abstraction over eBPF helper arguments thanks to wrapping structs
* add bpf_landlock_get_fs_mode() helper to check file type and mode
* merge WARN_ON() (suggested by Kees Cook)
* fix and update bpf_helpers.h
* use BPF_CALL_* for eBPF helpers (suggested by Alexei Starovoitov)
* make handle arraymap safe (RCU) and remove buggy synchronize_rcu()
* factor out the arraymay walk
* use size_t to index array (suggested by Jann Horn)
Changes since v2:
* add MNT_INTERNAL check to only add file handle from user-visible FS (e.g. no anonymous inode)
* replace struct file* with struct path* in map_landlock_handle
* add BPF protos
* fix bpf_landlock_cmp_fs_prop_with_struct_file()
--- include/linux/bpf.h | 18 ++ include/linux/bpf_types.h | 3 + include/linux/landlock.h | 24 +++ include/uapi/linux/bpf.h | 22 ++- kernel/bpf/Makefile | 3 + kernel/bpf/core.c | 1 + kernel/bpf/helpers.c | 38 +++++ kernel/bpf/inodemap.c | 318 +++++++++++++++++++++++++++++++++++ kernel/bpf/syscall.c | 27 ++- kernel/bpf/verifier.c | 25 +++ security/landlock/Makefile | 1 + security/landlock/tag.c | 373 +++++++++++++++++++++++++++++++++++++++++ security/landlock/tag.h | 36 ++++ security/landlock/tag_fs.c | 59 +++++++ security/landlock/tag_fs.h | 26 +++ tools/include/uapi/linux/bpf.h | 22 ++- 16 files changed, 993 insertions(+), 3 deletions(-) create mode 100644 kernel/bpf/inodemap.c create mode 100644 security/landlock/tag.c create mode 100644 security/landlock/tag.h create mode 100644 security/landlock/tag_fs.c create mode 100644 security/landlock/tag_fs.h
include/linux/bpf.h +18 -0
@@ -127,6 +127,10 @@ enum bpf_arg_type {ARG_PTR_TO_CTX ,/* pointer to context */ ARG_ANYTHING ,/* any (initialized) argument is ok */ + +ARG_PTR_TO_INODE ,/* pointer to a struct inode */ +ARG_PTR_TO_LL_TAG_OBJ ,/* pointer to a struct landlock_tag_object */ + ARG_PTR_TO_LL_CHAIN, /* pointer to a struct landlock_chain */ };/* type of values returned from helper functions */
@@ -184,6 +188,9 @@ enum bpf_reg_type {PTR_TO_PACKET_META ,/* skb->data - meta_len */ PTR_TO_PACKET ,/* reg points to skb->data */ PTR_TO_PACKET_END ,/* skb->data + headlen */ +PTR_TO_INODE ,/* reg points to struct inode */ +PTR_TO_LL_TAG_OBJ ,/* reg points to struct landlock_tag_object */ + PTR_TO_LL_CHAIN, /* reg points to struct landlock_chain */ };/* The information passed from prog-specific *_is_valid_access
@@ -306,6 +313,10 @@ struct bpf_event_entry {struct rcu_head rcu; }; + +u64 bpf_tail_call (u64 ctx,u64 r2,u64 index,u64 r4,u64 r5); +u64 bpf_get_stackid (u64 r1,u64 r2,u64 r3,u64 r4,u64 r5); +bool bpf_prog_array_compatible (struct bpf_array *array,const struct bpf_prog *fp);int bpf_prog_calc_tag (struct bpf_prog *fp);
@@ -447,6 +458,10 @@ void bpf_fd_array_map_clear(struct bpf_map *map);int bpf_fd_htab_map_update_elem (struct bpf_map *map,struct file *map_file,void *key,void *value,u64 map_flags);int bpf_fd_htab_map_lookup_elem (struct bpf_map *map,void *key,u32 *value); +int bpf_inode_map_update_elem (struct bpf_map *map,int *key,u64 *value, +u64 flags); +int bpf_inode_map_lookup_elem (struct bpf_map *map,int *key,u64 *value); +int bpf_inode_map_delete_elem (struct bpf_map *map,int *key);int bpf_get_file_flag (int flags);
@@ -686,6 +701,9 @@ extern const struct bpf_func_proto bpf_skb_vlan_push_proto;extern const struct bpf_func_proto bpf_skb_vlan_pop_proto;extern const struct bpf_func_proto bpf_get_stackid_proto;extern const struct bpf_func_proto bpf_sock_map_update_proto; +extern const struct bpf_func_proto bpf_inode_map_lookup_proto; +extern const struct bpf_func_proto bpf_inode_get_tag_proto; +extern const struct bpf_func_proto bpf_landlock_set_tag_proto;/* Shared helpers among cBPF and eBPF. */ void bpf_user_rnd_init_once (void );
include/linux/bpf_types.h +3 -0
@@ -50,3 +50,6 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_SOCKMAP, sock_map_ops)#endif BPF_MAP_TYPE(BPF_MAP_TYPE_CPUMAP, cpu_map_ops)#endif +#ifdef CONFIG_SECURITY_LANDLOCK +BPF_MAP_TYPE(BPF_MAP_TYPE_INODE, inode_ops) +#endif
include/linux/landlock.h +24 -0
@@ -15,6 +15,30 @@#include <linux/errno.h> #include <linux/sched.h> /* task_struct */ +struct inode ; +struct landlock_chain ; +struct landlock_tag_object ; + +#ifdef CONFIG_SECURITY_LANDLOCK +extern u64 landlock_get_inode_tag (const struct inode *inode, +const struct landlock_chain *chain); +extern int landlock_set_object_tag (struct landlock_tag_object *tag_obj, +struct landlock_chain *chain,u64 value); +#else /* CONFIG_SECURITY_LANDLOCK */ +static inline u64 landlock_get_inode_tag (const struct inode *inode, +const struct landlock_chain *chain) +{ +WARN_ON (1 ); +return 0 ; +} +static inline int landlock_set_object_tag (struct landlock_tag_object *tag_obj, +struct landlock_chain *chain,u64 value) +{ +WARN_ON (1 ); +return -ENOTSUPP ; +} +#endif /* CONFIG_SECURITY_LANDLOCK */ +#if defined(CONFIG_SECCOMP_FILTER ) && defined(CONFIG_SECURITY_LANDLOCK )extern int landlock_seccomp_prepend_prog (unsigned int flags,const int __user *user_bpf_fd);
include/uapi/linux/bpf.h +21 -1
@@ -114,6 +114,7 @@ enum bpf_map_type {BPF_MAP_TYPE_DEVMAP ,BPF_MAP_TYPE_SOCKMAP ,BPF_MAP_TYPE_CPUMAP , + BPF_MAP_TYPE_INODE, }; enum bpf_prog_type {
@@ -708,6 +709,22 @@ union bpf_attr {* int bpf_override_return(pt_regs, rc) * @pt_regs: pointer to struct pt_regs * @rc: the return value to set +* +* u64 bpf_inode_map_lookup(map, key) +* @map: pointer to inode map +* @key: pointer to inode +* Return: value tied to this key, or zero if none +* +* u64 bpf_inode_get_tag(inode, chain) +* @inode: pointer to struct inode +* @chain: pointer to struct landlock_chain +* Return: tag tied to this inode and chain, or zero if none +* +* int bpf_landlock_set_tag(tag_obj, chain, value) +* @tag_obj: pointer pointing to a taggable object (e.g. inode) +* @chain: pointer to struct landlock_chain +* @value: value of the tag +* Return: 0 on success or negative error code */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -769,7 +786,10 @@ union bpf_attr {FN (perf_prog_read_value), \FN (getsockopt), \FN (override_return), \ -FN (sock_ops_cb_flags_set), +FN (sock_ops_cb_flags_set), \ +FN (inode_map_lookup), \ +FN (inode_get_tag), \ +FN (landlock_set_tag),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
kernel/bpf/Makefile +3 -0
@@ -18,3 +18,6 @@ ifeq ($(CONFIG_PERF_EVENTS),y) obj-$(CONFIG_BPF_SYSCALL) += stackmap.o endif obj-$(CONFIG_CGROUP_BPF) += cgroup.o +ifeq ($(CONFIG_SECURITY_LANDLOCK),y) +obj-$(CONFIG_BPF_SYSCALL) += inodemap.o +endif
kernel/bpf/core.c +1 -0
@@ -1772,6 +1772,7 @@ const struct bpf_func_proto bpf_get_current_pid_tgid_proto __weak;const struct bpf_func_proto bpf_get_current_uid_gid_proto__weak ;const struct bpf_func_proto bpf_get_current_comm_proto__weak ;const struct bpf_func_proto bpf_sock_map_update_proto__weak ; +const struct bpf_func_proto bpf_inode_map_update_proto__weak ;const struct bpf_func_proto *__weak bpf_get_trace_printk_proto (void ) {
kernel/bpf/helpers.c +38 -0
@@ -18,6 +18,7 @@#include <linux/sched.h> #include <linux/uidgid.h> #include <linux/filter.h> +#include <linux/landlock.h> /* If kernel subsystem is allowing eBPF programs to call this function, * inside its own verifier_ops->get_func_proto() callback it should return
@@ -179,3 +180,40 @@ const struct bpf_func_proto bpf_get_current_comm_proto = { .arg1_type = ARG_PTR_TO_UNINIT_MEM, .arg2_type = ARG_CONST_SIZE, }; + +BPF_CALL_2(bpf_inode_get_tag, void *, inode, void *, chain) +{ +if (WARN_ON (!inode)) +return 0 ; +if (WARN_ON (!chain)) +return 0 ; + +return landlock_get_inode_tag (inode, chain); +} + +const struct bpf_func_proto bpf_inode_get_tag_proto = { + .func = bpf_inode_get_tag, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_INODE , + .arg2_type =ARG_PTR_TO_LL_CHAIN , +}; + +BPF_CALL_3(bpf_landlock_set_tag, void *, tag_obj, void *, chain, u64, value) +{ +if (WARN_ON (!tag_obj)) +return -EFAULT ; +if (WARN_ON (!chain)) +return -EFAULT ; + +return landlock_set_object_tag (tag_obj, chain, value); +} + +const struct bpf_func_proto bpf_landlock_set_tag_proto = { + .func = bpf_landlock_set_tag, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_LL_TAG_OBJ , + .arg2_type =ARG_PTR_TO_LL_CHAIN , + .arg3_type =ARG_ANYTHING , +};
kernel/bpf/inodemap.c new file +318 -0
318 lines not on this page · raw message
kernel/bpf/syscall.c +26 -1
@@ -554,6 +554,22 @@ int __weak bpf_stackmap_copy(struct bpf_map *map, void *key, void *value)return -ENOTSUPP ; } +int __weak bpf_inode_map_update_elem (struct bpf_map *map,int *key, +u64 *value,u64 flags) +{ +return -ENOTSUPP ; +} + +int __weak bpf_inode_map_lookup_elem (struct bpf_map *map,int *key,u64 *value) +{ +return -ENOTSUPP ; +} + +int __weak bpf_inode_map_delete_elem (struct bpf_map *map,int *key) +{ +return -ENOTSUPP ; +} +/* last field in 'union bpf_attr' used by this command */ #define BPF_MAP_LOOKUP_ELEM_LAST_FIELD value
@@ -614,6 +630,8 @@ static int map_lookup_elem(union bpf_attr *attr) err =bpf_fd_array_map_lookup_elem (map, key, value); }else if (IS_FD_HASH (map)) { err =bpf_fd_htab_map_lookup_elem (map, key, value); + }else if (map->map_type ==BPF_MAP_TYPE_INODE ) { + err =bpf_inode_map_lookup_elem (map, key, value); }else {rcu_read_lock (); ptr = map->ops->map_lookup_elem (map, key);
@@ -719,6 +737,10 @@ static int map_update_elem(union bpf_attr *attr) err =bpf_fd_htab_map_update_elem (map, f.file, key, value, attr->flags);rcu_read_unlock (); + }else if (map->map_type ==BPF_MAP_TYPE_INODE ) { +rcu_read_lock (); + err =bpf_inode_map_update_elem (map, key, value, attr->flags); +rcu_read_unlock (); }else {rcu_read_lock (); err = map->ops->map_update_elem (map, key, value, attr->flags);
@@ -776,7 +798,10 @@ static int map_delete_elem(union bpf_attr *attr)preempt_disable ();__this_cpu_inc (bpf_prog_active);rcu_read_lock (); - err = map->ops->map_delete_elem (map, key); +if (map->map_type ==BPF_MAP_TYPE_INODE ) + err =bpf_inode_map_delete_elem (map, key); +else + err = map->ops->map_delete_elem (map, key);rcu_read_unlock ();__this_cpu_dec (bpf_prog_active);preempt_enable ();
kernel/bpf/verifier.c +25 -0
@@ -224,6 +224,9 @@ static const char * const reg_type_str[] = { [PTR_TO_PACKET] = "pkt", [PTR_TO_PACKET_META] = "pkt_meta", [PTR_TO_PACKET_END] = "pkt_end", + [PTR_TO_INODE] = "inode", + [PTR_TO_LL_TAG_OBJ] = "landlock_tag_object", + [PTR_TO_LL_CHAIN] = "landlock_chain", }; static void print_liveness(struct bpf_verifier_env *env,
@@ -949,6 +952,9 @@ static bool is_spillable_regtype(enum bpf_reg_type type)case PTR_TO_PACKET_META :case PTR_TO_PACKET_END :case CONST_PTR_TO_MAP : +case PTR_TO_INODE : +case PTR_TO_LL_TAG_OBJ : +case PTR_TO_LL_CHAIN :return true;default :return false;
@@ -1909,6 +1915,18 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 regno, expected_type =PTR_TO_CTX ;if (type != expected_type) goto err_type; + }else if (arg_type ==ARG_PTR_TO_INODE ) { + expected_type =PTR_TO_INODE ; +if (type != expected_type) + goto err_type; + }else if (arg_type ==ARG_PTR_TO_LL_TAG_OBJ ) { + expected_type =PTR_TO_LL_TAG_OBJ ; +if (type != expected_type) + goto err_type; + }else if (arg_type ==ARG_PTR_TO_LL_CHAIN ) { + expected_type =PTR_TO_LL_CHAIN ; +if (type != expected_type) + goto err_type; }else if (arg_type_is_mem_ptr (arg_type)) { expected_type =PTR_TO_STACK ;/* One exception here. In case function allows for NULL to be
@@ -2066,6 +2084,10 @@ static int check_map_func_compatibility(struct bpf_verifier_env *env, func_id != BPF_FUNC_map_delete_elem) goto error;break ; +case BPF_MAP_TYPE_INODE : +if (func_id != BPF_FUNC_inode_map_lookup) + goto error; +break ;default :break ; }
@@ -2108,6 +2130,9 @@ static int check_map_func_compatibility(struct bpf_verifier_env *env,if (map->map_type !=BPF_MAP_TYPE_SOCKMAP ) goto error;break ; +case BPF_FUNC_inode_map_lookup: +if (map->map_type !=BPF_MAP_TYPE_INODE ) + goto error;default :break ; }
security/landlock/Makefile +1 -0
@@ -1,4 +1,5 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o \ + tag.o tag_fs.o \ enforce.o enforce_seccomp.o
security/landlock/tag.c new file +373 -0
373 lines not on this page · raw message
security/landlock/tag.h new file +36 -0
@@ -0,0 +1,36 @@ +/* +* Landlock LSM - tag headers +* +* Copyright © 2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#ifndef _SECURITY_LANDLOCK_TAG_H +#define _SECURITY_LANDLOCK_TAG_H + +#include <linux/spinlock_types.h> + +struct landlock_tag ; +struct landlock_tag_root ; +struct landlock_tag_ref ; + +struct landlock_tag_object { +spinlock_t *lock; +struct landlock_tag_root **root; +struct landlock_tag_ref **ref; +}; + +int landlock_set_tag (struct landlock_tag_ref **tag_ref, +struct landlock_tag_root **tag_root, +spinlock_t *root_lock, +struct landlock_chain *chain,u64 value); +u64 landlock_get_tag (const struct landlock_tag_root *tag_root, +const struct landlock_chain *chain); +void landlock_free_tag_ref (struct landlock_tag_ref *tag_ref, +struct landlock_tag_root **tag_root,spinlock_t *root_lock); + +#endif /* _SECURITY_LANDLOCK_TAG_H */
security/landlock/tag_fs.c new file +59 -0
59 lines not on this page · raw message
security/landlock/tag_fs.h new file +26 -0
@@ -0,0 +1,26 @@ +/* +* Landlock LSM - tag FS headers +* +* Copyright © 2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#ifndef _SECURITY_LANDLOCK_TAG_FS_H +#define _SECURITY_LANDLOCK_TAG_FS_H + +#include <linux/fs.h> /* struct inode */ + +struct landlock_tag_fs { +struct inode *inode; +struct landlock_tag_ref *ref; +}; + +struct landlock_tag_fs *landlock_new_tag_fs (struct inode *inode); +void landlock_reset_tag_fs (struct landlock_tag_fs *tag_fs,struct inode *inode); +void landlock_free_tag_fs (struct landlock_tag_fs *tag_fs); + +#endif /* _SECURITY_LANDLOCK_TAG_FS_H */
tools/include/uapi/linux/bpf.h +21 -1
@@ -114,6 +114,7 @@ enum bpf_map_type {BPF_MAP_TYPE_DEVMAP ,BPF_MAP_TYPE_SOCKMAP ,BPF_MAP_TYPE_CPUMAP , + BPF_MAP_TYPE_INODE, }; enum bpf_prog_type {
@@ -708,6 +709,22 @@ union bpf_attr {* int bpf_override_return(pt_regs, rc) * @pt_regs: pointer to struct pt_regs * @rc: the return value to set +* +* u64 bpf_inode_map_lookup(map, key) +* @map: pointer to inode map +* @key: pointer to inode +* Return: value tied to this key, or zero if none +* +* u64 bpf_inode_get_tag(inode, chain) +* @inode: pointer to struct inode +* @chain: pointer to struct landlock_chain +* Return: tag tied to this inode and chain, or zero if none +* +* int bpf_landlock_set_tag(tag_obj, chain, value) +* @tag_obj: pointer pointing to a taggable object (e.g. inode) +* @chain: pointer to struct landlock_chain +* @value: value of the tag +* Return: 0 on success or negative error code */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -769,7 +786,10 @@ union bpf_attr {FN (perf_prog_read_value), \FN (getsockopt), \FN (override_return), \ -FN (sock_ops_cb_flags_set), +FN (sock_ops_cb_flags_set), \ +FN (inode_map_lookup), \ +FN (inode_get_tag), \ +FN (landlock_set_tag),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
Signature · 1 line
2.16.2
kbuild test robot
build botRe: [PATCH bpf-next v8 06/11] bpf,landlock: Add a new map type: inode
I love your patch! Perhaps something to improve:
Hi Mickaël,
I love your patch! Perhaps something to improve:
[auto build test WARNING on bpf-next/master]
url: https://github.com/0day-ci/linux/commits/Micka-l-Sala-n/Landlock-LSM-Toward-unprivileged-sandboxing/20180228-233659 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master reproduce: # apt-get install sparse make ARCH=x86_64 allmodconfig make C=1 CF=-D__CHECK_ENDIAN__
sparse warnings: (new ones prefixed by >>)
include/linux/init.h:134:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/init.h:135:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/init.h:268:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/init.h:269:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/printk.h:200:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:32:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:34:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:37:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:38:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:40:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:42:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:43:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:45:5: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:46:5: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:49:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/qspinlock.h:53:32: sparse: attribute 'indirect_branch': unknown attribute include/linux/workqueue.h:646:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/workqueue.h:647:5: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/numa.h:34:12: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/numa.h:35:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/numa.h:62:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/vmalloc.h:64:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/vmalloc.h:173:8: sparse: attribute 'indirect_branch': unknown attribute include/linux/vmalloc.h:174:8: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/fixmap.h:174:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/fixmap.h:176:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/fixmap.h:178:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/fixmap.h:180:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/apic.h:254:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/apic.h:430:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/io_apic.h:184:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/smp.h:113:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/smp.h:125:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/smp.h:126:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:110:33: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:112:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:114:12: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:118:12: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:126:12: sparse: attribute 'indirect_branch': unknown attribute include/linux/hrtimer.h:497:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/memory_hotplug.h:221:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/mmzone.h:1292:15: sparse: attribute 'indirect_branch': unknown attribute include/linux/kmemleak.h:29:33: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/kasan.h:29:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/kasan.h:30:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/pgtable.h:28:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/slab.h:135:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/slab.h:716:6: sparse: attribute 'indirect_branch': unknown attribute
>> security/landlock/tag.c:127:18: sparse: incompatible types in comparison expression (different address spaces)
security/landlock/tag.c:257:16: sparse: incompatible types in comparison expression (different address spaces) security/landlock/tag.c:263:24: sparse: incompatible types in comparison expression (different address spaces) security/landlock/tag.c:357:16: sparse: incompatible types in comparison expression (different address spaces)
--
arch/x86/include/asm/mem_encrypt.h:37:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:38:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:40:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:42:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:43:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:45:5: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:46:5: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/mem_encrypt.h:49:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/qspinlock.h:53:32: sparse: attribute 'indirect_branch': unknown attribute include/linux/workqueue.h:646:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/workqueue.h:647:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/wait_bit.h:41:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/numa.h:34:12: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/numa.h:35:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/numa.h:62:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/vmalloc.h:64:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/vmalloc.h:173:8: sparse: attribute 'indirect_branch': unknown attribute include/linux/vmalloc.h:174:8: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/fixmap.h:174:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/fixmap.h:176:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/fixmap.h:178:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/fixmap.h:180:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/apic.h:254:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/apic.h:430:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/io_apic.h:184:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/smp.h:113:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/smp.h:125:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/smp.h:126:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:110:33: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:112:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:114:12: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:118:12: sparse: attribute 'indirect_branch': unknown attribute include/linux/percpu.h:126:12: sparse: attribute 'indirect_branch': unknown attribute include/linux/fs.h:63:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/fs.h:64:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/fs.h:65:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/fs.h:66:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/memory_hotplug.h:221:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/mmzone.h:1292:15: sparse: attribute 'indirect_branch': unknown attribute include/linux/fs.h:2422:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/fs.h:2423:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/fs.h:3330:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/hrtimer.h:497:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/kmemleak.h:29:33: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/kasan.h:29:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/kasan.h:30:6: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/pgtable.h:28:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/slab.h:135:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/slab.h:716:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/mm.h:1753:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/mm.h:1941:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/mm.h:2083:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/mm.h:2671:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/swiotlb.h:39:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/swiotlb.h:124:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/swiotlb.h:9:12: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/swiotlb.h:10:12: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/swiotlb.h:11:13: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/swiotlb.h:12:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/dma-contiguous.h:85:5: sparse: attribute 'indirect_branch': unknown attribute arch/x86/include/asm/vdso.h:44:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/cred.h:167:13: sparse: attribute 'indirect_branch': unknown attribute include/linux/nsproxy.h:74:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/io.h:47:6: sparse: attribute 'indirect_branch': unknown attribute include/linux/netdevice.h:302:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/netdevice.h:4056:5: sparse: attribute 'indirect_branch': unknown attribute include/linux/ftrace.h:462:6: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/bpf.h:59:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/bpf.h:95:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/bpf.h:120:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/bpf.h:150:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/bpf.h:191:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/bpf.h:231:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/bpf.h:285:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/bpf.h:315:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/xdp.h:28:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/xdp.h:53:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/xdp.h:155:1: sparse: attribute 'indirect_branch': unknown attribute include/trace/events/xdp.h:190:1: sparse: attribute 'indirect_branch': unknown attribute
kernel/bpf/core.c:1549:31: sparse: incorrect type in return expression (different address spaces) @@ expected struct bpf_prog_array [noderef] <asn:4>* @@ got sn:4>* @@
kernel/bpf/core.c:1549:31: expected struct bpf_prog_array [noderef] <asn:4>*
kernel/bpf/core.c:1549:31: got void *
kernel/bpf/core.c:1553:17: sparse: incorrect type in return expression (different address spaces) @@ expected struct bpf_prog_array [noderef] <asn:4>* @@ got rray [noderef] <asn:4>* @@
kernel/bpf/core.c:1553:17: expected struct bpf_prog_array [noderef] <asn:4>*
kernel/bpf/core.c:1553:17: got struct bpf_prog_array *<noident>
kernel/bpf/core.c:1561:9: sparse: incorrect type in argument 1 (different address spaces) @@ expected struct callback_head *head @@ got struct callback_hstruct callback_head *head @@
kernel/bpf/core.c:1561:9: expected struct callback_head *head
kernel/bpf/core.c:1561:9: got struct callback_head [noderef] <asn:4>*<noident>
kernel/bpf/core.c:1624:34: sparse: incorrect type in initializer (different address spaces) @@ expected struct bpf_prog **prog @@ got struct bpf_prog *struct bpf_prog **prog @@
kernel/bpf/core.c:1624:34: expected struct bpf_prog **prog
kernel/bpf/core.c:1624:34: got struct bpf_prog *[noderef] <asn:4>*<noident>
kernel/bpf/core.c:1647:31: sparse: incorrect type in assignment (different address spaces) @@ expected struct bpf_prog **existing_prog @@ got struct bpf_prog *struct bpf_prog **existing_prog @@
kernel/bpf/core.c:1647:31: expected struct bpf_prog **existing_prog
kernel/bpf/core.c:1647:31: got struct bpf_prog *[noderef] <asn:4>*<noident>
kernel/bpf/core.c:1669:15: sparse: incorrect type in assignment (different address spaces) @@ expected struct bpf_prog_array *array @@ got struct bpf_prog_astruct bpf_prog_array *array @@
kernel/bpf/core.c:1669:15: expected struct bpf_prog_array *array
kernel/bpf/core.c:1669:15: got struct bpf_prog_array [noderef] <asn:4>*
kernel/bpf/core.c:1675:31: sparse: incorrect type in assignment (different address spaces) @@ expected struct bpf_prog **[assigned] existing_prog @@ got structstruct bpf_prog **[assigned] existing_prog @@
kernel/bpf/core.c:1675:31: expected struct bpf_prog **[assigned] existing_prog
kernel/bpf/core.c:1675:31: got struct bpf_prog *[noderef] <asn:4>*<noident>
include/trace/events/bpf.h:59:1: sparse: Using plain integer as NULL pointer include/trace/events/bpf.h:95:1: sparse: Using plain integer as NULL pointer include/trace/events/bpf.h:120:1: sparse: Using plain integer as NULL pointer include/trace/events/bpf.h:191:1: sparse: Using plain integer as NULL pointer include/trace/events/bpf.h:231:1: sparse: Using plain integer as NULL pointer include/trace/events/bpf.h:285:1: sparse: too many warnings
vim +127 security/landlock/tag.c
116
117 /* return true if the tag_root is queued for freeing, false otherwise */
118 static void put_tag_root(struct landlock_tag_root **root,
119 spinlock_t *root_lock)
120 {
121 struct landlock_tag_root *freeme;
122
123 if (!root || WARN_ON(!root_lock))
124 return;
125
126 rcu_read_lock();
> 127 freeme = rcu_dereference(*root);
128 if (WARN_ON(!freeme))
129 goto out_rcu;
130 if (!refcount_dec_and_lock(&freeme->tag_nb, root_lock))
131 goto out_rcu;
132
133 rcu_assign_pointer(*root, NULL);
134 spin_unlock(root_lock);
135 call_rcu(&freeme->rcu_put, put_tag_root_rcu);
136
137 out_rcu:
138 rcu_read_unlock();
139 }
140
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
Mickaël Salaün
maintainerPATCH v8 7/11 landlock: Handle filesystem access control
In reply to Mickaël SalaünThis add three Landlock: FS_WALK, FS_PICK and FS_GET.
The FS_WALK hook is used to walk through a file path. A program tied to this hook will be evaluated for each directory traversal except the last one if it is the leaf of the path.
The FS_PICK hook is used to validate a set of actions requested on a file. This actions are defined with triggers (e.g. read, write, open, append...).
The FS_GET hook is used to tag open files, which is necessary to be able to evaluate relative paths. A program tied to this hook can tag a file with an inode map.
A Landlock program can be chained to another if it is permitted by the BPF verifier. A FS_WALK can be chained to a FS_PICK which can be chained to a FS_GET.
The Landlock LSM hook registration is done after other LSM to only run actions from user-space, via eBPF programs, if the access was granted by major (privileged) LSMs.
---
Changes since v7:
* major rewrite with clean Landlock hooks able to deal with file paths
Changes since v6:
* add 3 more sub-events: IOCTL, LOCK, FCNTL
https://lkml.kernel.org/r/[email protected]
* use the new security_add_hooks()
* explain the -Werror=unused-function
* constify pointers
* cleanup headers
Changes since v5:
* split hooks.[ch] into hooks.[ch] and hooks_fs.[ch]
* add more documentation
* cosmetic fixes
* rebase (SCALAR_VALUE)
Changes since v4:
* add LSM hook abstraction called Landlock event
* use the compiler type checking to verify hooks use by an event
* handle all filesystem related LSM hooks (e.g. file_permission,
mmap_file, sb_mount...)
* register BPF programs for Landlock just after LSM hooks registration
* move hooks registration after other LSMs
* add failsafes to check if a hook is not used by the kernel
* allow partial raw value access form the context (needed for programs generated by LLVM)
Changes since v3:
* split commit
* add hooks dealing with struct inode and struct path pointers:
inode_permission and inode_getattr
* add abstraction over eBPF helper arguments thanks to wrapping structs
--- include/linux/lsm_hooks.h | 5 + security/landlock/Makefile | 5 +- security/landlock/common.h | 9 + security/landlock/enforce_seccomp.c | 10 + security/landlock/hooks.c | 121 +++++ security/landlock/hooks.h | 35 ++ security/landlock/hooks_cred.c | 52 ++ security/landlock/hooks_cred.h | 1 + security/landlock/hooks_fs.c | 1021 +++++++++++++++++++++++++++++++++++ security/landlock/hooks_fs.h | 60 ++ security/landlock/init.c | 56 ++ security/landlock/task.c | 34 ++ security/landlock/task.h | 29 + security/security.c | 12 +- 14 files changed, 1447 insertions(+), 3 deletions(-) create mode 100644 security/landlock/hooks.c create mode 100644 security/landlock/hooks.h create mode 100644 security/landlock/hooks_cred.c create mode 100644 security/landlock/hooks_cred.h create mode 100644 security/landlock/hooks_fs.c create mode 100644 security/landlock/hooks_fs.h create mode 100644 security/landlock/task.c create mode 100644 security/landlock/task.h
include/linux/lsm_hooks.h +5 -0
@@ -2032,5 +2032,10 @@ void __init loadpin_add_hooks(void);#else static inline void loadpin_add_hooks (void ) { };#endif +#ifdef CONFIG_SECURITY_LANDLOCK +extern void __init landlock_add_hooks (void ); +#else +static inline void __init landlock_add_hooks (void ) { } +#endif /* CONFIG_SECURITY_LANDLOCK */ #endif /* ! __LINUX_LSM_HOOKS_H */
security/landlock/Makefile +3 -2
@@ -1,5 +1,6 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o -landlock-y := init.o chain.o \ +landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ - enforce.o enforce_seccomp.o + enforce.o enforce_seccomp.o \ + hooks.o hooks_cred.o hooks_fs.o
security/landlock/common.h +9 -0
@@ -82,4 +82,13 @@ static inline enum landlock_hook_type get_type(struct bpf_prog *prog) return prog->aux->extra->subtype.landlock_hook.type; } +__maybe_unused +static bool current_has_prog_type (enum landlock_hook_type hook_type) +{ +struct landlock_prog_set *prog_set; + + prog_set = current->seccomp.landlock_prog_set; +return (prog_set && prog_set->programs[get_index (hook_type)]); +} +#endif /* _SECURITY_LANDLOCK_COMMON_H */
security/landlock/enforce_seccomp.c +10 -0
@@ -22,6 +22,7 @@#include <linux/uaccess.h> /* get_user() */ #include "enforce.h" +#include "task.h" /* headers in include/linux/landlock.h */
@@ -64,6 +65,13 @@ int landlock_seccomp_prepend_prog(unsigned int flags,if (err)return err; +/* allocate current->security here to not have to handle this in +* hook_nameidata_free_security() */ +if (!current->security) { + current->security =landlock_new_task_security (GFP_KERNEL ); +if (!current->security) +return -ENOMEM ; + } prog =bpf_prog_get (bpf_fd);if (IS_ERR (prog)) { err =PTR_ERR (prog);
@@ -86,6 +94,8 @@ int landlock_seccomp_prepend_prog(unsigned int flags,return 0 ; free_task: +landlock_free_task_security (current->security); + current->security =NULL ;return err; }
security/landlock/hooks.c new file +121 -0
121 lines not on this page · raw message
security/landlock/hooks.h new file +35 -0
@@ -0,0 +1,35 @@ +/* +* Landlock LSM - hooks helpers +* +* Copyright © 2016-2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <asm/current.h> +#include <linux/sched.h> /* struct task_struct */ +#include <linux/seccomp.h> + +#include "hooks_fs.h" + +struct landlock_hook_ctx { +union { +struct landlock_hook_ctx_fs_walk *fs_walk; +struct landlock_hook_ctx_fs_pick *fs_pick; +struct landlock_hook_ctx_fs_get *fs_get; + }; +}; + +static inline bool landlocked (const struct task_struct *task) +{ +#ifdef CONFIG_SECCOMP_FILTER +return !!(task->seccomp.landlock_prog_set); +#else +return false; +#endif /* CONFIG_SECCOMP_FILTER */ +} + +int landlock_decide (enum landlock_hook_type ,struct landlock_hook_ctx *,u64 );
security/landlock/hooks_cred.c new file +52 -0
52 lines not on this page · raw message
security/landlock/hooks_cred.h new file +1 -0
@@ -0,0 +1 @@ +__init void landlock_add_hooks_cred (void );
security/landlock/hooks_fs.c new file +1021 -0
1,021 lines not on this page · raw message
security/landlock/hooks_fs.h new file +60 -0
60 lines not on this page · raw message
security/landlock/init.c +56 -0
79 lines not on this page · raw message
security/landlock/task.c new file +34 -0
@@ -0,0 +1,34 @@ +/* +* Landlock LSM - task helpers +* +* Copyright © 2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <linux/slab.h> +#include <linux/types.h> /* gfp_t */ + +#include "hooks_fs.h" /* landlock_free_walk_list() */ +#include "tag_fs.h" +#include "task.h" + +/* TODO: inherit tsec->root and tsec->cwd on fork/execve */ + +void landlock_free_task_security (struct landlock_task_security *tsec) +{ +if (!tsec) +return ; +landlock_free_walk_list (tsec->walk_list); +landlock_free_tag_fs (tsec->root); +landlock_free_tag_fs (tsec->cwd); +kfree (tsec); +} + +struct landlock_task_security *landlock_new_task_security (gfp_t gfp) +{ +return kzalloc (sizeof (struct landlock_task_security ), gfp); +}
security/landlock/task.h new file +29 -0
@@ -0,0 +1,29 @@ +/* +* Landlock LSM - task headers +* +* Copyright © 2018 Mickaël Salaün <[email protected]> +* Copyright © 2018 ANSSI +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#ifndef _SECURITY_LANDLOCK_TASK_H +#define _SECURITY_LANDLOCK_TASK_H + +#include <linux/types.h> /* gfp_t */ + +#include "hooks_fs.h" +#include "tag_fs.h" + +/* exclusively used by the current task (i.e. no concurrent access) */ +struct landlock_task_security { +struct landlock_walk_list *walk_list; +struct landlock_tag_fs *root, *cwd; +}; + +struct landlock_task_security *landlock_new_task_security (gfp_t gfp); +void landlock_free_task_security (struct landlock_task_security *tsec); + +#endif /* _SECURITY_LANDLOCK_TASK_H */
security/security.c +11 -1
@@ -76,10 +76,20 @@ int __init security_init(void)loadpin_add_hooks ();/* -* Load all the remaining security modules. +* Load all remaining privileged security modules. */ do_security_initcalls (); +/* +* Load potentially-unprivileged security modules at the end. +* +* For an unprivileged access-control, we don't want to give the +* ability to any process to do some checks (e.g. through an eBPF +* program) on kernel objects (e.g. files) if a privileged security +* policy forbid their access. +*/ +landlock_add_hooks (); +return 0 ; }
Signature · 1 line
2.16.2
Mickaël Salaün
maintainerPATCH v8 8/11 landlock: Add ptrace restrictions
In reply to Mickaël SalaünA landlocked process has less privileges than a non-landlocked process and must then be subject to additional restrictions when manipulating processes. To be allowed to use ptrace(2) and related syscalls on a target process, a landlocked process must have a subset of the target process' rules.
---
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the new security_add_hooks()
--- security/landlock/Makefile | 2 +- security/landlock/hooks_ptrace.c | 124 +++++++++++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 11 ++++ security/landlock/init.c | 2 + 4 files changed, 138 insertions(+), 1 deletion(-) create mode 100644 security/landlock/hooks_ptrace.c create mode 100644 security/landlock/hooks_ptrace.h
security/landlock/Makefile +1 -1
@@ -3,4 +3,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ enforce.o enforce_seccomp.o \ - hooks.o hooks_cred.o hooks_fs.o + hooks.o hooks_cred.o hooks_fs.o hooks_ptrace.o
security/landlock/hooks_ptrace.c new file +124 -0
124 lines not on this page · raw message
security/landlock/hooks_ptrace.h new file +11 -0
@@ -0,0 +1,11 @@ +/* +* Landlock LSM - ptrace hooks +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +__init void landlock_add_hooks_ptrace (void );
security/landlock/init.c +2 -0
@@ -17,6 +17,7 @@#include "common.h" /* LANDLOCK_* */ #include "hooks_fs.h" #include "hooks_cred.h" +#include "hooks_ptrace.h" static bool bpf_landlock_is_valid_access(int off, int size, enum bpf_access_type type, struct bpf_insn_access_aux *info,
@@ -232,5 +233,6 @@ void __init landlock_add_hooks(void) {pr_info (LANDLOCK_NAME ": Ready to sandbox with seccomp\n" );landlock_add_hooks_cred (); +landlock_add_hooks_ptrace ();landlock_add_hooks_fs (); }
Signature · 1 line
2.16.2
Andy Lutomirski
reviewerRe: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 68 lines · Mickaël Salaün
A landlocked process has less privileges than a non-landlocked process and must then be subject to additional restrictions when manipulating processes. To be allowed to use ptrace(2) and related syscalls on a target process, a landlocked process must have a subset of the target process' rules.
Signed-off-by Mickaël Salaün <[email protected]>Cc Alexei Starovoitov <[email protected]>Cc Andy Lutomirski <[email protected]>Cc Daniel Borkmann <[email protected]>Cc David S. Miller <[email protected]>Cc James Morris <[email protected]>Cc Kees Cook <[email protected]>Cc Serge E. Hallyn <[email protected]>---
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the newsecurity_add_hooks()--- security/landlock/Makefile | 2 +- security/landlock/hooks_ptrace.c | 124 +++++++++++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 11 ++++ security/landlock/init.c | 2 + 4 files changed, 138 insertions(+), 1 deletion(-) create mode 100644 security/landlock/hooks_ptrace.c create mode 100644 security/landlock/hooks_ptrace.hsecurity/landlock/Makefile +1
-1@@ -3,4 +3,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ enforce.o enforce_seccomp.o \ - hooks.o hooks_cred.o hooks_fs.o + hooks.o hooks_cred.o hooks_fs.o hooks_ptrace.osecurity/landlock/hooks_ptrace.c new file +22
-0@@ -0,0 +1,124 @@ +/* +* Landlock LSM - ptrace hooks +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <asm/current.h> +#include <linux/errno.h> +#include <linux/kernel.h> /* ARRAY_SIZE */ +#include <linux/lsm_hooks.h> +#include <linux/sched.h> /* struct task_struct */ +#include <linux/seccomp.h> + +#include "common.h" /* struct landlock_prog_set */ +#include "hooks.h" /* landlocked() */ +#include "hooks_ptrace.h" + +static bool progs_are_subset(const struct landlock_prog_set *parent,
security/landlock/hooks_ptrace.c line 32
Quoted 10 lines
security/landlock/hooks_ptrace.c new file +10
-0+ const struct landlock_prog_set *child) +{ +size_t i; + +if (!parent || !child) +return false; +if (parent == child) +return true; + +for (i =0 ; i <ARRAY_SIZE (child->programs); i++) {
ARRAY_SIZE(child->programs) seems misleading. Is there no define NUM_LANDLOCK_PROG_TYPES or similar?
Quoted 7 lines
security/landlock/hooks_ptrace.c new file +7
-0+struct landlock_prog_list *walker; +bool found_parent = false; + +if (!parent->programs[i]) +continue ; +for (walker = child->programs[i]; walker; + walker = walker->prev) {
security/landlock/hooks_ptrace.c line 49
Quoted 10 lines
security/landlock/hooks_ptrace.c new file +10
-0+if (walker == parent->programs[i]) { + found_parent = true; +break ; + } + } +if (!found_parent) +return false; + } +return true; +}
If you used seccomp, you'd get this type of check for free, and it would be a lot easier to comprehend. AFAICT the only extra leniency you're granting is that you're agnostic to the order in which the rules associated with different program types were applied, which could easily be added to seccomp.
Andy Lutomirski
reviewerRe: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 102 lines · Andy Lutomirski
Quoted 70 lines · Mickaël Salaün
A landlocked process has less privileges than a non-landlocked process and must then be subject to additional restrictions when manipulating processes. To be allowed to use ptrace(2) and related syscalls on a target process, a landlocked process must have a subset of the target process' rules.
Signed-off-by Mickaël Salaün <[email protected]>Cc Alexei Starovoitov <[email protected]>Cc Andy Lutomirski <[email protected]>Cc Daniel Borkmann <[email protected]>Cc David S. Miller <[email protected]>Cc James Morris <[email protected]>Cc Kees Cook <[email protected]>Cc Serge E. Hallyn <[email protected]>---
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the newsecurity_add_hooks()
---security/landlock/Makefile | 2 +- security/landlock/hooks_ptrace.c | 124 +++++++++++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 11 ++++ security/landlock/init.c | 2 + 4 files changed, 138 insertions(+), 1 deletion(-)create mode 100644
security/landlock/hooks_ptrace.ccreate mode 100644security/landlock/hooks_ptrace.hsecurity/landlock/Makefile +1
-1@@ -3,4 +3,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ enforce.o enforce_seccomp.o \ - hooks.o hooks_cred.o hooks_fs.o + hooks.o hooks_cred.o hooks_fs.o hooks_ptrace.osecurity/landlock/hooks_ptrace.c new file +22
-0@@ -0,0 +1,124 @@ +/* +* Landlock LSM - ptrace hooks +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <asm/current.h> +#include <linux/errno.h> +#include <linux/kernel.h> /* ARRAY_SIZE */ +#include <linux/lsm_hooks.h> +#include <linux/sched.h> /* struct task_struct */ +#include <linux/seccomp.h> + +#include "common.h" /* struct landlock_prog_set */ +#include "hooks.h" /* landlocked() */ +#include "hooks_ptrace.h" + +static bool progs_are_subset(const struct landlock_prog_set *parent,security/landlock/hooks_ptrace.c line 32
Quoted 10 lines
security/landlock/hooks_ptrace.c new file +10
-0+ const struct landlock_prog_set *child) +{ +size_t i; + +if (!parent || !child) +return false; +if (parent == child) +return true; + +for (i =0 ; i <ARRAY_SIZE (child->programs); i++) {
ARRAY_SIZE(child->programs)seems misleading. Is there no defineNUM_LANDLOCK_PROG_TYPESor similar?Quoted 15 lines
security/landlock/hooks_ptrace.c new file +15
-0+struct landlock_prog_list *walker; +bool found_parent = false; + +if (!parent->programs[i]) +continue ; +for (walker = child->programs[i]; walker; + walker = walker->prev) { +if (walker == parent->programs[i]) { + found_parent = true; +break ; + } + } +if (!found_parent) +return false; + }
Quoted 8 lines
security/landlock/hooks_ptrace.c line 49
Quoted 2 lines
security/landlock/hooks_ptrace.c new file +2
-0+return true; +}If you used seccomp, you'd get this type of check for free, and it would be a lot easier to comprehend. AFAICT the only extra leniency you're granting is that you're agnostic to the order in which the rules associated with different program types were applied, which could easily be added to seccomp.
On second thought, this is all way too complicated. I think the correct logic is either "if you are filtered by Landlock, you cannot ptrace anything" or to delete this patch entirely. If something like Tycho's notifiers goes in, then it's not obvious that, just because you have the same set of filters, you have the same privilege. Similarly, if a feature that lets a filter query its cgroup goes in (and you proposed this once!) then the logic you implemented here is wrong.
Or you could just say that it's the responsibility of a Landlock user to properly filter ptrace() just like it's the responsibility of seccomp users to filter ptrace if needed.
I take this as further evidence that Landlock makes much more sense as part of seccomp than as a totally separate thing. We've very carefully reviewed these things for seccomp. Please don't make us do it again from scratch.
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 111 lines · Andy Lutomirski
Quoted 102 lines · Andy Lutomirski
Quoted 70 lines · Mickaël Salaün
A landlocked process has less privileges than a non-landlocked process and must then be subject to additional restrictions when manipulating processes. To be allowed to use ptrace(2) and related syscalls on a target process, a landlocked process must have a subset of the target process' rules.
Signed-off-by Mickaël Salaün <[email protected]>Cc Alexei Starovoitov <[email protected]>Cc Andy Lutomirski <[email protected]>Cc Daniel Borkmann <[email protected]>Cc David S. Miller <[email protected]>Cc James Morris <[email protected]>Cc Kees Cook <[email protected]>Cc Serge E. Hallyn <[email protected]>---
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the newsecurity_add_hooks()
---security/landlock/Makefile | 2 +- security/landlock/hooks_ptrace.c | 124 +++++++++++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 11 ++++ security/landlock/init.c | 2 + 4 files changed, 138 insertions(+), 1 deletion(-)create mode 100644
security/landlock/hooks_ptrace.ccreate mode 100644security/landlock/hooks_ptrace.hsecurity/landlock/Makefile +1
-1@@ -3,4 +3,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ enforce.o enforce_seccomp.o \ - hooks.o hooks_cred.o hooks_fs.o + hooks.o hooks_cred.o hooks_fs.o hooks_ptrace.osecurity/landlock/hooks_ptrace.c new file +22
-0@@ -0,0 +1,124 @@ +/* +* Landlock LSM - ptrace hooks +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <asm/current.h> +#include <linux/errno.h> +#include <linux/kernel.h> /* ARRAY_SIZE */ +#include <linux/lsm_hooks.h> +#include <linux/sched.h> /* struct task_struct */ +#include <linux/seccomp.h> + +#include "common.h" /* struct landlock_prog_set */ +#include "hooks.h" /* landlocked() */ +#include "hooks_ptrace.h" + +static bool progs_are_subset(const struct landlock_prog_set *parent,security/landlock/hooks_ptrace.c line 32
Quoted 10 lines
security/landlock/hooks_ptrace.c new file +10
-0+ const struct landlock_prog_set *child) +{ +size_t i; + +if (!parent || !child) +return false; +if (parent == child) +return true; + +for (i =0 ; i <ARRAY_SIZE (child->programs); i++) {
ARRAY_SIZE(child->programs)seems misleading. Is there no defineNUM_LANDLOCK_PROG_TYPESor similar?Quoted 15 lines
security/landlock/hooks_ptrace.c new file +15
-0+struct landlock_prog_list *walker; +bool found_parent = false; + +if (!parent->programs[i]) +continue ; +for (walker = child->programs[i]; walker; + walker = walker->prev) { +if (walker == parent->programs[i]) { + found_parent = true; +break ; + } + } +if (!found_parent) +return false; + }Quoted 8 lines
security/landlock/hooks_ptrace.c line 49
Quoted 2 lines
security/landlock/hooks_ptrace.c new file +2
-0+return true; +}If you used seccomp, you'd get this type of check for free, and it would be a lot easier to comprehend. AFAICT the only extra leniency you're granting is that you're agnostic to the order in which the rules associated with different program types were applied, which could easily be added to seccomp.
Quoted 1 line
On second thought, this is all way too complicated. I think the correct logic is either "if you are filtered by Landlock, you cannot ptrace anything" or to delete this patch entirely.
This does not fit a lot of use cases like running a container constrained with some Landlock programs. We should not deny users the ability to debug their stuff.
This patch add the minimal protection which are needed to have meaningful Landlock security policy. Without it, they may be easily bypassable, hence useless.
Quoted 1 line
If something like Tycho's notifiers goes in, then it's not obvious that, just because you have the same set of filters, you have the same privilege. Similarly, if a feature that lets a filter query its cgroup goes in (and you proposed this once!) then the logic you implemented here is wrong.
I don't get your point. Please take a look at the tests (patch 10).
Quoted 2 lines
Or you could just say that it's the responsibility of a Landlock user to properly filter
ptrace()just like it's the responsibility of seccomp users to filter ptrace if needed.
A user should be able to enforce a security policy on ptrace as well, but this patch enforce a minimal set of security boundaries. It will be easy to add a new Landlock program type to get this kind of access control.
Quoted 3 lines
I take this as further evidence that Landlock makes much more sense as part of seccomp than as a totally separate thing. We've very carefully reviewed these things for seccomp. Please don't make us do it again from scratch.
Landlock is more complex than seccomp, because of its different goal. seccomp is less restrictive because it is more simple, but this patch follow the same logic with the knowledge of the Landlock internals.
Re: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 115 lines · Mickaël Salaün
Quoted 111 lines · Andy Lutomirski
Quoted 102 lines · Andy Lutomirski
Quoted 70 lines · Mickaël Salaün
A landlocked process has less privileges than a non-landlocked process and must then be subject to additional restrictions when manipulating processes. To be allowed to use ptrace(2) and related syscalls on a target process, a landlocked process must have a subset of the target process' rules.
Signed-off-by Mickaël Salaün <[email protected]>Cc Alexei Starovoitov <[email protected]>Cc Andy Lutomirski <[email protected]>Cc Daniel Borkmann <[email protected]>Cc David S. Miller <[email protected]>Cc James Morris <[email protected]>Cc Kees Cook <[email protected]>Cc Serge E. Hallyn <[email protected]>---
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the newsecurity_add_hooks()
---security/landlock/Makefile | 2 +- security/landlock/hooks_ptrace.c | 124 +++++++++++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 11 ++++ security/landlock/init.c | 2 + 4 files changed, 138 insertions(+), 1 deletion(-)create mode 100644
security/landlock/hooks_ptrace.ccreate mode 100644security/landlock/hooks_ptrace.hsecurity/landlock/Makefile +1
-1@@ -3,4 +3,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ enforce.o enforce_seccomp.o \ - hooks.o hooks_cred.o hooks_fs.o + hooks.o hooks_cred.o hooks_fs.o hooks_ptrace.osecurity/landlock/hooks_ptrace.c new file +22
-0@@ -0,0 +1,124 @@ +/* +* Landlock LSM - ptrace hooks +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <asm/current.h> +#include <linux/errno.h> +#include <linux/kernel.h> /* ARRAY_SIZE */ +#include <linux/lsm_hooks.h> +#include <linux/sched.h> /* struct task_struct */ +#include <linux/seccomp.h> + +#include "common.h" /* struct landlock_prog_set */ +#include "hooks.h" /* landlocked() */ +#include "hooks_ptrace.h" + +static bool progs_are_subset(const struct landlock_prog_set *parent,security/landlock/hooks_ptrace.c line 32
Quoted 10 lines
security/landlock/hooks_ptrace.c new file +10
-0+ const struct landlock_prog_set *child) +{ +size_t i; + +if (!parent || !child) +return false; +if (parent == child) +return true; + +for (i =0 ; i <ARRAY_SIZE (child->programs); i++) {
ARRAY_SIZE(child->programs)seems misleading. Is there no defineNUM_LANDLOCK_PROG_TYPESor similar?Quoted 15 lines
security/landlock/hooks_ptrace.c new file +15
-0+struct landlock_prog_list *walker; +bool found_parent = false; + +if (!parent->programs[i]) +continue ; +for (walker = child->programs[i]; walker; + walker = walker->prev) { +if (walker == parent->programs[i]) { + found_parent = true; +break ; + } + } +if (!found_parent) +return false; + }Quoted 8 lines
security/landlock/hooks_ptrace.c line 49
Quoted 2 lines
security/landlock/hooks_ptrace.c new file +2
-0+return true; +}If you used seccomp, you'd get this type of check for free, and it would be a lot easier to comprehend. AFAICT the only extra leniency you're granting is that you're agnostic to the order in which the rules associated with different program types were applied, which could easily be added to seccomp.
Quoted 1 line
On second thought, this is all way too complicated. I think the correct logic is either "if you are filtered by Landlock, you cannot ptrace anything" or to delete this patch entirely.
Quoted 8 lines
This does not fit a lot of use cases like running a container constrained with some Landlock programs. We should not deny users the ability to debug their stuff.
This patch add the minimal protection which are needed to have meaningful Landlock security policy. Without it, they may be easily bypassable, hence useless.
I think you're wrong here. Any sane container trying to use Landlock like this would also create a PID namespace. Problem solved. I still think you should drop this patch.
Quoted 4 lines
Quoted 2 lines
If something like Tycho's notifiers goes in, then it's not obvious that, just because you have the same set of filters, you have the same privilege. Similarly, if a feature that lets a filter query its cgroup goes in (and you proposed this once!) then the logic you implemented here is wrong.
I don't get your point. Please take a look at the tests (patch 10).
I don't know what you want me to look at.
What I'm saying is: suppose I write a filter like this:
bool allow_some_action(void)
{
int value_from_container_manager = call_out_to_user_notifier(); return value_from_container_manager == 42;
}
or
bool allow_some_action(void)
{
return my_cgroup_is("/foo/bar");
}
In both of these cases, your code will do the wrong thing.
Quoted 7 lines
Quoted 3 lines
Or you could just say that it's the responsibility of a Landlock user to properly filter
ptrace()just like it's the responsibility of seccomp users to filter ptrace if needed.A user should be able to enforce a security policy on ptrace as well, but this patch enforce a minimal set of security boundaries. It will be easy to add a new Landlock program type to get this kind of access control.
It sounds like you want Landlock to be a complete container system all by itself. I disagree with that design goal.
Re: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 155 lines · Andy Lutomirski
Quoted 115 lines · Mickaël Salaün
Quoted 111 lines · Andy Lutomirski
Quoted 102 lines · Andy Lutomirski
Quoted 70 lines · Mickaël Salaün
A landlocked process has less privileges than a non-landlocked process and must then be subject to additional restrictions when manipulating processes. To be allowed to use ptrace(2) and related syscalls on a target process, a landlocked process must have a subset of the target process' rules.
Signed-off-by Mickaël Salaün <[email protected]>Cc Alexei Starovoitov <[email protected]>Cc Andy Lutomirski <[email protected]>Cc Daniel Borkmann <[email protected]>Cc David S. Miller <[email protected]>Cc James Morris <[email protected]>Cc Kees Cook <[email protected]>Cc Serge E. Hallyn <[email protected]>---
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the newsecurity_add_hooks()
---security/landlock/Makefile | 2 +- security/landlock/hooks_ptrace.c | 124 +++++++++++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 11 ++++ security/landlock/init.c | 2 + 4 files changed, 138 insertions(+), 1 deletion(-)create mode 100644
security/landlock/hooks_ptrace.ccreate mode 100644security/landlock/hooks_ptrace.hsecurity/landlock/Makefile +1
-1@@ -3,4 +3,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ enforce.o enforce_seccomp.o \ - hooks.o hooks_cred.o hooks_fs.o + hooks.o hooks_cred.o hooks_fs.o hooks_ptrace.osecurity/landlock/hooks_ptrace.c new file +22
-0@@ -0,0 +1,124 @@ +/* +* Landlock LSM - ptrace hooks +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <asm/current.h> +#include <linux/errno.h> +#include <linux/kernel.h> /* ARRAY_SIZE */ +#include <linux/lsm_hooks.h> +#include <linux/sched.h> /* struct task_struct */ +#include <linux/seccomp.h> + +#include "common.h" /* struct landlock_prog_set */ +#include "hooks.h" /* landlocked() */ +#include "hooks_ptrace.h" + +static bool progs_are_subset(const struct landlock_prog_set *parent,security/landlock/hooks_ptrace.c line 32
Quoted 10 lines
security/landlock/hooks_ptrace.c new file +10
-0+ const struct landlock_prog_set *child) +{ +size_t i; + +if (!parent || !child) +return false; +if (parent == child) +return true; + +for (i =0 ; i <ARRAY_SIZE (child->programs); i++) {
ARRAY_SIZE(child->programs)seems misleading. Is there no defineNUM_LANDLOCK_PROG_TYPESor similar?Quoted 15 lines
security/landlock/hooks_ptrace.c new file +15
-0+struct landlock_prog_list *walker; +bool found_parent = false; + +if (!parent->programs[i]) +continue ; +for (walker = child->programs[i]; walker; + walker = walker->prev) { +if (walker == parent->programs[i]) { + found_parent = true; +break ; + } + } +if (!found_parent) +return false; + }Quoted 8 lines
security/landlock/hooks_ptrace.c line 49
Quoted 2 lines
security/landlock/hooks_ptrace.c new file +2
-0+return true; +}If you used seccomp, you'd get this type of check for free, and it would be a lot easier to comprehend. AFAICT the only extra leniency you're granting is that you're agnostic to the order in which the rules associated with different program types were applied, which could easily be added to seccomp.
Quoted 1 line
On second thought, this is all way too complicated. I think the correct logic is either "if you are filtered by Landlock, you cannot ptrace anything" or to delete this patch entirely.
Quoted 8 lines
This does not fit a lot of use cases like running a container constrained with some Landlock programs. We should not deny users the ability to debug their stuff.
This patch add the minimal protection which are needed to have meaningful Landlock security policy. Without it, they may be easily bypassable, hence useless.
I think you're wrong here. Any sane container trying to use Landlock like this would also create a PID namespace. Problem solved. I still think you should drop this patch.
Quoted 4 lines
Quoted 2 lines
If something like Tycho's notifiers goes in, then it's not obvious that, just because you have the same set of filters, you have the same privilege. Similarly, if a feature that lets a filter query its cgroup goes in (and you proposed this once!) then the logic you implemented here is wrong.
I don't get your point. Please take a look at the tests (patch 10).
I don't know what you want me to look at.
What I'm saying is: suppose I write a filter like this:
bool
allow_some_action(void)
{
intvalue_from_container_manager=call_out_to_user_notifier(); returnvalue_from_container_manager== 42;
}or
bool
allow_some_action(void)
{
returnmy_cgroup_is("/foo/bar");
}In both of these cases, your code will do the wrong thing.
Quoted 2 lines
Quoted 2 lines
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
Or you could just say that it's the responsibility of a Landlock user to properly filter
ptrace()just like it's the responsibility of seccomp users to filter ptrace if needed.A user should be able to enforce a security policy on ptrace as well, but this patch enforce a minimal set of security boundaries. It will be easy to add a new Landlock program type to get this kind of access control.
It sounds like you want Landlock to be a complete container system all by itself. I disagree with that design goal.
Having actually read your series more correctly now (oops!), I still think that this patch should be dropped. I can see an argument for having a flag that one can set when adding a seccomp filter that says "prevent ptrace of any child that doesn't have this exact stack installed", but I think that could be added later and should not be part of an initial submission. For now, Landlock users can block ptrace() entirely or use PID namespaces.
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 121 lines · Andy Lutomirski
Quoted 120 lines · Andy Lutomirski
Quoted 119 lines · Mickaël Salaün
Quoted 111 lines · Andy Lutomirski
Quoted 102 lines · Andy Lutomirski
Quoted 70 lines · Mickaël Salaün
A landlocked process has less privileges than a non-landlocked process and must then be subject to additional restrictions when manipulating processes. To be allowed to use ptrace(2) and related syscalls on a target process, a landlocked process must have a subset of the target process' rules.
Signed-off-by Mickaël Salaün <[email protected]>Cc Alexei Starovoitov <[email protected]>Cc Andy Lutomirski <[email protected]>Cc Daniel Borkmann <[email protected]>Cc David S. Miller <[email protected]>Cc James Morris <[email protected]>Cc Kees Cook <[email protected]>Cc Serge E. Hallyn <[email protected]>---
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the newsecurity_add_hooks()
---security/landlock/Makefile | 2 +- security/landlock/hooks_ptrace.c | 124 +++++++++++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 11 ++++ security/landlock/init.c | 2 + 4 files changed, 138 insertions(+), 1 deletion(-)create mode 100644
security/landlock/hooks_ptrace.ccreate mode 100644security/landlock/hooks_ptrace.hsecurity/landlock/Makefile +1
-1@@ -3,4 +3,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ enforce.o enforce_seccomp.o \ - hooks.o hooks_cred.o hooks_fs.o + hooks.o hooks_cred.o hooks_fs.o hooks_ptrace.osecurity/landlock/hooks_ptrace.c new file +22
-0@@ -0,0 +1,124 @@ +/* +* Landlock LSM - ptrace hooks +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <asm/current.h> +#include <linux/errno.h> +#include <linux/kernel.h> /* ARRAY_SIZE */ +#include <linux/lsm_hooks.h> +#include <linux/sched.h> /* struct task_struct */ +#include <linux/seccomp.h> + +#include "common.h" /* struct landlock_prog_set */ +#include "hooks.h" /* landlocked() */ +#include "hooks_ptrace.h" + +static bool progs_are_subset(const struct landlock_prog_set *parent,security/landlock/hooks_ptrace.c line 32
Quoted 10 lines
security/landlock/hooks_ptrace.c new file +10
-0+ const struct landlock_prog_set *child) +{ +size_t i; + +if (!parent || !child) +return false; +if (parent == child) +return true; + +for (i =0 ; i <ARRAY_SIZE (child->programs); i++) {
ARRAY_SIZE(child->programs)seems misleading. Is there no defineNUM_LANDLOCK_PROG_TYPESor similar?Quoted 15 lines
security/landlock/hooks_ptrace.c new file +15
-0+struct landlock_prog_list *walker; +bool found_parent = false; + +if (!parent->programs[i]) +continue ; +for (walker = child->programs[i]; walker; + walker = walker->prev) { +if (walker == parent->programs[i]) { + found_parent = true; +break ; + } + } +if (!found_parent) +return false; + }Quoted 8 lines
security/landlock/hooks_ptrace.c line 49
Quoted 2 lines
security/landlock/hooks_ptrace.c new file +2
-0+return true; +}If you used seccomp, you'd get this type of check for free, and it would be a lot easier to comprehend. AFAICT the only extra leniency you're granting is that you're agnostic to the order in which the rules associated with different program types were applied, which could easily be added to seccomp.
Quoted 1 line
On second thought, this is all way too complicated. I think the correct logic is either "if you are filtered by Landlock, you cannot ptrace anything" or to delete this patch entirely.
This does not fit a lot of use cases like running a container constrained with some Landlock programs. We should not deny users the ability to debug their stuff.
Quoted 8 lines
Quoted 8 lines
Quoted 4 lines
This patch add the minimal protection which are needed to have meaningful Landlock security policy. Without it, they may be easily bypassable, hence useless.
I think you're wrong here. Any sane container trying to use Landlock like this would also create a PID namespace. Problem solved. I still think you should drop this patch.
Containers is one use case, another is build-in sandboxing (e.g. for web browser…) and another one is for sandbox managers (e.g. Firejail, Bubblewrap, Flatpack…). In some of these use cases, especially from a developer point of view, you may want/need to debug your applications (without requiring to be root). For nested Landlock access-controls (e.g. container + user session + web browser), it may not be allowed to create a PID namespace, but you still want to have a meaningful access-control.
Quoted 16 lines
Quoted 16 lines
Quoted 5 lines
Quoted 3 lines
If something like Tycho's notifiers goes in, then it's not obvious that, just because you have the same set of filters, you have the same privilege. Similarly, if a feature that lets a filter query its cgroup goes in (and you proposed this once!) then the logic you implemented here is wrong.
I don't get your point. Please take a look at the tests (patch 10).
I don't know what you want me to look at.
What I'm saying is: suppose I write a filter like this:
bool
allow_some_action(void)
{
intvalue_from_container_manager=call_out_to_user_notifier(); returnvalue_from_container_manager== 42;
}
Quoted 8 lines
Quoted 8 lines
or
bool
allow_some_action(void)
{
returnmy_cgroup_is("/foo/bar");
}In both of these cases, your code will do the wrong thing.
You are right about the fact that the same filters/programs may not be equivalent if they use external data (other than from the eBPF context) to take a decision. This is why using a function my_cgroup_is("/foo/bar") should not be allowed. If we want to enforce a security policy according to a cgroup, the Landlock programs should be pinned on this cgroup. This way, the kernel knows if this programs should be called or not. It is the same argument I used in the thread [PATCH bpf-next v8 05/11] about the cache.
The only way a Landlock program may change its behavior is because of an eBPF map. However, in this case the map is common to all the instances of this program.
To say it another way, the Landlock's enforce API (currently only seccomp) is in charge of defining what is a subject. By using seccomp to enforce a policy, the subject is a hierarchy of processes. By pinning a Landlock program to a cgroup, the subject is the set of processes under this cgroup. This is much more efficient than letting a program define its one subjects. This also allows to audit which processes are restricted by a set of Landlock programs. Because of that, calls to functions like bpf_get_current_pid_tgid() should not be allowed (or limited) for a Landlock program. Let's make this programs as pure as possible. :)
Quoted 12 lines
Quoted 11 lines
Quoted 8 lines
Quoted 4 lines
Or you could just say that it's the responsibility of a Landlock user to properly filter
ptrace()just like it's the responsibility of seccomp users to filter ptrace if needed.A user should be able to enforce a security policy on ptrace as well, but this patch enforce a minimal set of security boundaries. It will be easy to add a new Landlock program type to get this kind of access control.
It sounds like you want Landlock to be a complete container system all by itself. I disagree with that design goal.
Quoted 8 lines
Having actually read your series more correctly now (oops!), I still think that this patch should be dropped. I can see an argument for having a flag that one can set when adding a seccomp filter that says "prevent ptrace of any child that doesn't have this exact stack installed", but I think that could be added later and should not be part of an initial submission. For now, Landlock users can block
ptrace()entirely or use PID namespaces.
I also though about using a flag, but we should encourage sane/safe default behavior, which means at least to not have trivially bypassable access-control rules, to not shoot yourself in the foot. However, a flag could be added to disable this safe behavior.
Re: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 10 lines · Mickaël Salaün
Quoted 7 lines · Andy Lutomirski
Quoted 6 lines · Andy Lutomirski
Quoted 1 line · Mickaël Salaün
I think you're wrong here. Any sane container trying to use Landlock like this would also create a PID namespace. Problem solved. I still think you should drop this patch.
Quoted 9 lines
Containers is one use case, another is build-in sandboxing (e.g. for web browser…) and another one is for sandbox managers (e.g. Firejail, Bubblewrap, Flatpack…). In some of these use cases, especially from a developer point of view, you may want/need to debug your applications (without requiring to be root). For nested Landlock access-controls (e.g. container + user session + web browser), it may not be allowed to create a PID namespace, but you still want to have a meaningful access-control.
The consideration should be exactly the same as for normal seccomp. If I'm in a container (using PID namespaces + seccomp) and a run a web browser, I can debug the browser.
If there's a real use case for adding this type of automatic ptrace protection, then by all means, let's add it as a general seccomp feature.
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 21 lines · Andy Lutomirski
Quoted 10 lines · Mickaël Salaün
Quoted 7 lines · Andy Lutomirski
Quoted 6 lines · Andy Lutomirski
Quoted 1 line · Mickaël Salaün
I think you're wrong here. Any sane container trying to use Landlock like this would also create a PID namespace. Problem solved. I still think you should drop this patch.
Quoted 9 lines
Containers is one use case, another is build-in sandboxing (e.g. for web browser…) and another one is for sandbox managers (e.g. Firejail, Bubblewrap, Flatpack…). In some of these use cases, especially from a developer point of view, you may want/need to debug your applications (without requiring to be root). For nested Landlock access-controls (e.g. container + user session + web browser), it may not be allowed to create a PID namespace, but you still want to have a meaningful access-control.
Quoted 8 lines
The consideration should be exactly the same as for normal seccomp. If I'm in a container (using PID namespaces + seccomp) and a run a web browser, I can debug the browser.
If there's a real use case for adding this type of automatic ptrace protection, then by all means, let's add it as a general seccomp feature.
Right, it makes sense to add this feature to seccomp filters as well. What do you think Kees?
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
Quoted 27 lines · Mickaël Salaün
Quoted 25 lines · Andy Lutomirski
Quoted 10 lines · Mickaël Salaün
Quoted 7 lines · Andy Lutomirski
Quoted 6 lines · Andy Lutomirski
Quoted 1 line · Mickaël Salaün
I think you're wrong here. Any sane container trying to use Landlock like this would also create a PID namespace. Problem solved. I still think you should drop this patch.
Quoted 9 lines
Containers is one use case, another is build-in sandboxing (e.g. for web browser…) and another one is for sandbox managers (e.g. Firejail, Bubblewrap, Flatpack…). In some of these use cases, especially from a developer point of view, you may want/need to debug your applications (without requiring to be root). For nested Landlock access-controls (e.g. container + user session + web browser), it may not be allowed to create a PID namespace, but you still want to have a meaningful access-control.
The consideration should be exactly the same as for normal seccomp. If I'm in a container (using PID namespaces + seccomp) and a run a web browser, I can debug the browser.
Quoted 8 lines
Quoted 4 lines
If there's a real use case for adding this type of automatic ptrace protection, then by all means, let's add it as a general seccomp feature.
Right, it makes sense to add this feature to seccomp filters as well. What do you think Kees?
As a second though, it may be useful for seccomp but it should be another patch series, independent from this one.
The idea to keep in mind is that this ptrace restriction is an automatic way to define what is called a subject in common access control vocabulary, like used by SELinux. A subject should not be able to impersonate another one with less restrictions (to get more rights). Because of the stackable restrictions of Landlock (same principle used by seccomp), it is easy to identify which subject (i.e. group of processes) is more restricted (or with different restrictions) than another. This follow the same principle as Yama's ptrace_scope.
Another important argument for a different ptrace-protection mechanism than seccomp is that Landlock programs may be applied (i.e. define subject) otherwise than with a process hierarchy. Another way to define a Landlock subject may be by using cgroups (which was previously discussed). I'm also thinking about being able to create (real) capabilities (not to be confused with POSIX capabilities), which may be useful to implement some parts of Capsicum, by attaching Landlock programs to a file descriptor (and not directly to a group of processes). All this to highlight that the ptrace protection is specific to Landlock and may not be directly shared with seccomp.
Even if Landlock follows the footprints of seccomp, they are different beasts.
Mickaël Salaün
maintainerRe: [PATCH bpf-next v8 08/11] landlock: Add ptrace restrictions
In reply to Andy LutomirskiQuoted 74 lines · Andy Lutomirski
Quoted 73 lines · Mickaël Salaün
A landlocked process has less privileges than a non-landlocked process and must then be subject to additional restrictions when manipulating processes. To be allowed to use ptrace(2) and related syscalls on a target process, a landlocked process must have a subset of the target process' rules.
Signed-off-by Mickaël Salaün <[email protected]>Cc Alexei Starovoitov <[email protected]>Cc Andy Lutomirski <[email protected]>Cc Daniel Borkmann <[email protected]>Cc David S. Miller <[email protected]>Cc James Morris <[email protected]>Cc Kees Cook <[email protected]>Cc Serge E. Hallyn <[email protected]>---
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the newsecurity_add_hooks()--- security/landlock/Makefile | 2 +- security/landlock/hooks_ptrace.c | 124 +++++++++++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 11 ++++ security/landlock/init.c | 2 + 4 files changed, 138 insertions(+), 1 deletion(-) create mode 100644 security/landlock/hooks_ptrace.c create mode 100644 security/landlock/hooks_ptrace.hsecurity/landlock/Makefile +1
-1@@ -3,4 +3,4 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o chain.o task.o \ tag.o tag_fs.o \ enforce.o enforce_seccomp.o \ - hooks.o hooks_cred.o hooks_fs.o + hooks.o hooks_cred.o hooks_fs.o hooks_ptrace.osecurity/landlock/hooks_ptrace.c new file +27
-0@@ -0,0 +1,124 @@ +/* +* Landlock LSM - ptrace hooks +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <asm/current.h> +#include <linux/errno.h> +#include <linux/kernel.h> /* ARRAY_SIZE */ +#include <linux/lsm_hooks.h> +#include <linux/sched.h> /* struct task_struct */ +#include <linux/seccomp.h> + +#include "common.h" /* struct landlock_prog_set */ +#include "hooks.h" /* landlocked() */ +#include "hooks_ptrace.h" + +static bool progs_are_subset (const struct landlock_prog_set *parent, +const struct landlock_prog_set *child) +{ +size_t i; + +if (!parent || !child)
Quoted 8 lines
security/landlock/hooks_ptrace.c line 32
Quoted 5 lines
security/landlock/hooks_ptrace.c new file +5
-0+return false; +if (parent == child) +return true; + +for (i =0 ; i <ARRAY_SIZE (child->programs); i++) {
ARRAY_SIZE(child->programs)seems misleading. Is there no defineNUM_LANDLOCK_PROG_TYPESor similar?
Yes, there is _LANDLOCK_HOOK_LAST, but this code seems more readable exactly because it does not require the developer (or the code checking tools) to know about this static value.
Mickaël Salaün
maintainerPATCH v8 9/11 bpf: Add a Landlock sandbox example
In reply to Mickaël SalaünAdd a basic sandbox tool to launch a command which is only allowed to access in a read only or read-write way a whitelist of file hierarchies.
Add to the bpf_load library the ability to handle a BPF program subtype.
---
Changes since v7:
* rewrite the example using an inode map
* add to bpf_load the ability to handle subtypes per program type
Changes since v6:
* check return value of load_and_attach()
* allow to write on pipes
* rename BPF_PROG_TYPE_LANDLOCK to BPF_PROG_TYPE_LANDLOCK_RULE
* rename Landlock version to ABI to better reflect its purpose
* use const variable (suggested by Kees Cook)
* remove useless definitions (suggested by Kees Cook)
* add detailed explanations (suggested by Kees Cook)
Changes since v5:
* cosmetic fixes
* rebase
Changes since v4:
* write Landlock rule in C and compiled it with LLVM
* remove cgroup handling
* remove path handling: only handle a read-only environment
* remove errno return codes
Changes since v3:
* remove seccomp and origin field: completely free from seccomp programs
* handle more FS-related hooks
* handle inode hooks and directory traversal
* add faked but consistent view thanks to ENOENT
* add /lib64 in the example
* fix spelling
* rename some types and definitions (e.g. SECCOMP_ADD_LANDLOCK_RULE)
Changes since v2:
* use BPF_PROG_ATTACH for cgroup handling
--- samples/bpf/Makefile | 4 + samples/bpf/bpf_load.c | 82 ++++++++++++++++++++- samples/bpf/bpf_load.h | 7 ++ samples/bpf/landlock1.h | 14 ++++ samples/bpf/landlock1_kern.c | 171 +++++++++++++++++++++++++++++++++++++++++++ samples/bpf/landlock1_user.c | 164 +++++++++++++++++++++++++++++++++++++++++ 6 files changed, 439 insertions(+), 3 deletions(-) create mode 100644 samples/bpf/landlock1.h create mode 100644 samples/bpf/landlock1_kern.c create mode 100644 samples/bpf/landlock1_user.c
samples/bpf/Makefile +4 -0
@@ -43,6 +43,7 @@ hostprogs-y += xdp_redirect_cpu hostprogs-y += xdp_monitor hostprogs-y += xdp_rxq_info hostprogs-y += syscall_tp +hostprogs-y += landlock1 # Libbpf dependencies LIBBPF := ../../tools/lib/bpf/bpf.o ../../tools/lib/bpf/nlattr.o
@@ -93,6 +94,7 @@ xdp_redirect_cpu-objs := bpf_load.o $(LIBBPF) xdp_redirect_cpu_user.o xdp_monitor-objs := bpf_load.o $(LIBBPF) xdp_monitor_user.o xdp_rxq_info-objs := bpf_load.o $(LIBBPF) xdp_rxq_info_user.o syscall_tp-objs := bpf_load.o $(LIBBPF) syscall_tp_user.o +landlock1-objs := bpf_load.o $(LIBBPF) landlock1_user.o # Tell kbuild to always build the programs always := $(hostprogs-y)
@@ -144,6 +146,7 @@ always += xdp_monitor_kern.o always += xdp_rxq_info_kern.o always += xdp2skb_meta_kern.o always += syscall_tp_kern.o +always += landlock1_kern.o HOSTCFLAGS += -I$(objtree)/usr/include HOSTCFLAGS += -I$(srctree)/tools/lib/
@@ -188,6 +191,7 @@ HOSTLOADLIBES_xdp_redirect_cpu += -lelf HOSTLOADLIBES_xdp_monitor += -lelf HOSTLOADLIBES_xdp_rxq_info += -lelf HOSTLOADLIBES_syscall_tp += -lelf +HOSTLOADLIBES_landlock1 += -lelf # Allows pointing LLC/CLANG to a LLVM backend with bpf support, redefine on cmdline: # make samples/bpf/ LLC=~/git/llvm/build/bin/llc CLANG=~/git/llvm/build/bin/clang
samples/bpf/bpf_load.c +79 -3
139 lines not on this page · raw message
samples/bpf/bpf_load.h +7 -0
@@ -24,6 +24,13 @@ struct bpf_map_data {struct bpf_map_def def; }; +struct bpf_subtype_data { +char *name; +int prog_id; +int prog_fd; +union bpf_prog_subtype subtype; +}; +typedef void (*fixup_map_cb )(struct bpf_map_data *map,int idx);extern int prog_fd[MAX_PROGS ];
samples/bpf/landlock1.h new file +14 -0
@@ -0,0 +1,14 @@ +/* +* Landlock sample 1 - common header +* +* Copyright © 2018 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#define MAP_MARK_READ (1ULL << 63) +#define MAP_MARK_WRITE (1ULL << 62) +#define COOKIE_VALUE_FREEZED (1ULL << 61) +#define _MAP_MARK_MASK (MAP_MARK_READ | MAP_MARK_WRITE | COOKIE_VALUE_FREEZED)
samples/bpf/landlock1_kern.c new file +171 -0
171 lines not on this page · raw message
samples/bpf/landlock1_user.c new file +164 -0
164 lines not on this page · raw message
Signature · 1 line
2.16.2
Mickaël Salaün
maintainerPATCH v8 10/11 bpf,landlock: Add tests for Landlock
In reply to Mickaël SalaünTest basic context access, ptrace protection and filesystem hooks and Landlock program chaining with multiple cases.
---
Changes since v7:
* update tests and add new ones for filesystem hierarchy and Landlock chains.
Changes since v6:
* use the new kselftest_harness.h
* use const variables
* replace ASSERT_STEP with ASSERT_*
* rename BPF_PROG_TYPE_LANDLOCK to BPF_PROG_TYPE_LANDLOCK_RULE
* force sample library rebuild
* fix install target
Changes since v5:
* add subtype test
* add ptrace tests
* split and rename files
* cleanup and rebase
--- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/bpf/bpf_helpers.h | 7 + tools/testing/selftests/bpf/test_verifier.c | 84 +++++ tools/testing/selftests/landlock/.gitignore | 5 + tools/testing/selftests/landlock/Makefile | 35 ++ tools/testing/selftests/landlock/test.h | 31 ++ tools/testing/selftests/landlock/test_base.c | 27 ++ tools/testing/selftests/landlock/test_chain.c | 249 +++++++++++++ tools/testing/selftests/landlock/test_fs.c | 492 +++++++++++++++++++++++++ tools/testing/selftests/landlock/test_ptrace.c | 158 ++++++++ 10 files changed, 1089 insertions(+) create mode 100644 tools/testing/selftests/landlock/.gitignore create mode 100644 tools/testing/selftests/landlock/Makefile create mode 100644 tools/testing/selftests/landlock/test.h create mode 100644 tools/testing/selftests/landlock/test_base.c create mode 100644 tools/testing/selftests/landlock/test_chain.c create mode 100644 tools/testing/selftests/landlock/test_fs.c create mode 100644 tools/testing/selftests/landlock/test_ptrace.c
tools/testing/selftests/Makefile +1 -0
@@ -14,6 +14,7 @@ TARGETS += gpio TARGETS += intel_pstate TARGETS += ipc TARGETS += kcmp +TARGETS += landlock TARGETS += lib TARGETS += membarrier TARGETS += memfd
tools/testing/selftests/bpf/bpf_helpers.h +7 -0
@@ -86,6 +86,13 @@ static int (*bpf_perf_prog_read_value)(void *ctx, void *buf, (void *) BPF_FUNC_perf_prog_read_value;static int (*bpf_override_return)(void *ctx,unsigned long rc) = (void *) BPF_FUNC_override_return; +static unsigned long long (*bpf_inode_map_lookup)(void *map,void *key) = + (void *) BPF_FUNC_inode_map_lookup; +static unsigned long long (*bpf_inode_get_tag)(void *inode,void *chain) = + (void *) BPF_FUNC_inode_get_tag; +static unsigned long long (*bpf_landlock_set_tag)(void *tag_obj,void *chain, +unsigned long long value) = + (void *) BPF_FUNC_landlock_set_tag;/* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions
tools/testing/selftests/bpf/test_verifier.c +84 -0
96 lines not on this page · raw message
tools/testing/selftests/landlock/.gitignore new file +5 -0
@@ -0,0 +1,5 @@ +/test_base +/test_chain +/test_fs +/test_ptrace +/tmp_*
tools/testing/selftests/landlock/Makefile new file +35 -0
@@ -0,0 +1,35 @@ +LIBDIR := ../../../lib +OBJDIR := ../../../lib/bpf +BPFOBJS := $(OBJDIR)/bpf.o $(OBJDIR)/nlattr.o +LOADOBJ := ../../../../samples/bpf/bpf_load.o + +CFLAGS += -Wl,-no-as-needed -Wall -O2 -I../../../include/uapi -I$(LIBDIR) +LDFLAGS += -lelf + +test_src = $(wildcard test_*.c) + +test_objs := $(test_src:.c=) + +TEST_PROGS := $(test_objs) + +.PHONY: all clean force + +all: $(test_objs) + +# force a rebuild of BPFOBJS when its dependencies are updated +force: + +# rebuild bpf.o as a workaround for the samples/bpf bug +$(BPFOBJS): $(LOADOBJ) force + $(MAKE) -C $(OBJDIR) + +$(LOADOBJ): force + $(MAKE) -C $(dir $(LOADOBJ)) + +$(test_objs): $(BPFOBJS) $(LOADOBJ) ../kselftest_harness.h + +include ../lib.mk + +clean: + $(RM) $(test_objs) +
tools/testing/selftests/landlock/test.h new file +31 -0
@@ -0,0 +1,31 @@ +/* +* Landlock helpers +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#include <errno.h> +#include <linux/landlock.h> +#include <linux/seccomp.h> +#include <sys/prctl.h> +#include <sys/syscall.h> + +#include "../kselftest_harness.h" +#include "../../../../samples/bpf/bpf_load.h" + +#ifndef SECCOMP_PREPEND_LANDLOCK_PROG +#define SECCOMP_PREPEND_LANDLOCK_PROG 3 +#endif + +#ifndef seccomp +static int __attribute__((unused))seccomp (unsigned int op,unsigned int flags, +void *args) +{ + errno =0 ; +return syscall (__NR_seccomp, op, flags, args); +} +#endif
tools/testing/selftests/landlock/test_base.c new file +27 -0
@@ -0,0 +1,27 @@ +/* +* Landlock tests - base +* +* Copyright © 2017 Mickaël Salaün <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, as +* published by the Free Software Foundation. +*/ + +#define _GNU_SOURCE +#include <errno.h> + +#include "test.h" + +TEST (seccomp_landlock) +{ +int ret; + + ret =seccomp (SECCOMP_PREPEND_LANDLOCK_PROG ,0 ,NULL ); +EXPECT_EQ (-1 , ret); + EXPECT_EQ(EFAULT, errno) { +TH_LOG ("Kernel does not support CONFIG_SECURITY_LANDLOCK" ); + } +} + +TEST_HARNESS_MAIN
tools/testing/selftests/landlock/test_chain.c new file +249 -0
249 lines not on this page · raw message
tools/testing/selftests/landlock/test_fs.c new file +492 -0
492 lines not on this page · raw message
tools/testing/selftests/landlock/test_ptrace.c new file +158 -0
158 lines not on this page · raw message
Signature · 1 line
2.16.2
Mickaël Salaün
maintainerPATCH v8 11/11 landlock: Add user and kernel documentation for Landlock
In reply to Mickaël SalaünThis documentation can be built with the Sphinx framework.
---
Changes since v7:
* update documentation according to the Landlock revamp
Changes since v6:
* add a check for ctx->event
* rename BPF_PROG_TYPE_LANDLOCK to BPF_PROG_TYPE_LANDLOCK_RULE
* rename Landlock version to ABI to better reflect its purpose and add a dedicated changelog section
* update tables
* relax no_new_privs recommendations
* remove ABILITY_WRITE related functions
* reword rule "appending" to "prepending" and explain it
* cosmetic fixes
Changes since v5:
* update the rule hierarchy inheritance explanation
* briefly explain ctx->arg2
* add ptrace restrictions
* explain EPERM
* update example (subtype)
* use ":manpage:"
--- Documentation/security/index.rst | 1 + Documentation/security/landlock/index.rst | 19 +++ Documentation/security/landlock/kernel.rst | 100 ++++++++++++++ Documentation/security/landlock/user.rst | 206 +++++++++++++++++++++++++++++ 4 files changed, 326 insertions(+) create mode 100644 Documentation/security/landlock/index.rst create mode 100644 Documentation/security/landlock/kernel.rst create mode 100644 Documentation/security/landlock/user.rst
Documentation/security/index.rst +1 -0
@@ -11,3 +11,4 @@ Security Documentation LSM self-protection tpm/index + landlock/index
Documentation/security/landlock/index.rst new file +19 -0
@@ -0,0 +1,19 @@ +========================================= +Landlock LSM: programmatic access control +========================================= + +Landlock is a stackable Linux Security Module (LSM) that makes it possible to +create security sandboxes. This kind of sandbox is expected to help mitigate +the security impact of bugs or unexpected/malicious behaviors in user-space +applications. The current version allows only a process with the global +CAP_SYS_ADMIN capability to create such sandboxes but the ultimate goal of +Landlock is to empower any process, including unprivileged ones, to securely +restrict themselves. Landlock is inspired by seccomp-bpf but instead of +filtering syscalls and their raw arguments, a Landlock rule can inspect the use +of kernel objects like files and hence make a decision according to the kernel +semantic. + +.. toctree:: + + user + kernel
Documentation/security/landlock/kernel.rst new file +100 -0
100 lines not on this page · raw message
Documentation/security/landlock/user.rst new file +206 -0
206 lines not on this page · raw message
Signature · 1 line
2.16.2
Andy Lutomirski
reviewerQuoted 86 lines · Mickaël Salaün
Hi,
This eight series is a major revamp of the Landlock design compared to the previous series [1]. This enables more flexibility and granularity of access control with file paths. It is now possible to enforce an access control according to a file hierarchy. Landlock uses the concept of inode and path to identify such hierarchy. In a way, it brings tools to program what is a file hierarchy.
There is now three types of Landlock hooks:
FS_WALK,FS_PICKandFS_GET. Each of them accepts a dedicated eBPF program, called a Landlock program. They can be chained to enforce a full access control according to a list of directories or files. The set of actions on a file is well defined (e.g. read, write, ioctl, append, lock, mount...) taking inspiration from the major Linux LSMs and some other access-controls like Capsicum. These program types are designed to be cache-friendly, which give room for optimizations in the future.The documentation patch contains some kernel documentation and explanations on how to use Landlock. The compiled documentation and a talk I gave at FOSDEM can be found here: https://landlock.io
This patch series can be found in the branch landlock-v8 in this repo:
https://github.com/landlock-lsm/linuxThere is still some minor issues with this patch series but it should demonstrate how powerful this design may be. One of these issues is that it is not a stackable LSM anymore, but the infrastructure management of security blobs should allow to stack it with other LSM [4].
This is the first step of the roadmap discussed at LPC [2]. While the intended final goal is to allow unprivileged users to use Landlock, this series allows only a process with global
CAP_SYS_ADMINto load and enforce a rule. This may help to get feedback and avoid unexpected behaviors.This series can be applied on top of bpf-next, commit
7d72637eb39f("Merge branch 'x86-jit'"). This can be tested withCONFIG_SECCOMP_FILTERandCONFIG_SECURITY_LANDLOCK. I would really appreciate constructive comments on the design and the code.# Landlock LSM
The goal of this new Linux Security Module (LSM) called Landlock is to allow any process, including unprivileged ones, to create powerful security sandboxes comparable to XNU Sandbox or OpenBSD Pledge. This kind of sandbox is expected to help mitigate the security impact of bugs or unexpected/malicious behaviors in user-space applications.
The approach taken is to add the minimum amount of code while still allowing the user-space application to create quite complex access rules. A dedicated security policy language such as the one used by SELinux, AppArmor and other major LSMs involves a lot of code and is usually permitted to only a trusted user (i.e. root). On the contrary, eBPF programs already exist and are designed to be safely loaded by unprivileged user-space.
This design does not seem too intrusive but is flexible enough to allow a powerful sandbox mechanism accessible by any process on Linux. The use of seccomp and Landlock is more suitable with the help of a user-space library (e.g. libseccomp) that could help to specify a high-level language to express a security policy instead of raw eBPF programs. Moreover, thanks to the LLVM front-end, it is quite easy to write an eBPF program with a subset of the C language.
# Frequently asked questions
## Why is seccomp-bpf not enough?
A seccomp filter can access only raw syscall arguments (i.e. the register values) which means that it is not possible to filter according to the value pointed to by an argument, such as a file pathname. As an embryonic Landlock version demonstrated, filtering at the syscall level is complicated (e.g. need to take care of race conditions). This is mainly because the access control checkpoints of the kernel are not at this high-level but more underneath, at the LSM-hook level. The LSM hooks are designed to handle this kind of checks. Landlock abstracts this approach to leverage the ability of unprivileged users to limit themselves.
Cf. section "What it isn't?" in
Documentation/prctl/seccomp_filter.txt## Why use the seccomp(2) syscall?
Quoted 8 lines
Landlock use the same semantic as seccomp to apply access rule restrictions. It add a new layer of security for the current process which is inherited by its children. It makes sense to use an unique access-restricting syscall (that should be allowed by seccomp filters) which can only drop privileges. Moreover, a Landlock rule could come from outside a process (e.g. passed through a UNIX socket). It is then useful to differentiate the creation/load of Landlock eBPF programs via bpf(2), from rule enforcement via seccomp(2).
This seems like a weak argument to me. Sure, this is a bit different from seccomp(), and maybe shoving it into the seccomp() multiplexer is awkward, but surely the bpf() multiplexer is even less applicable.
But I think that you have more in common with seccomp() than you're giving it credit for. With seccomp, you need to either prevent ptrace() of any more-privileged task or you need to filter to make sure you can't trace a more privileged program. With landlock, you need exactly the same thing. You have basically the same no_new_privs considerations, etc.
Also, looking forward, I think you're going to want a bunch of the stuff that's under consideration as new seccomp features. Tycho is working on a "user notifier" feature for seccomp where, in addition to accepting, rejecting, or kicking to ptrace, you can send a message to the creator of the filter and wait for a reply. I think that Landlock will want exactly the same feature.
In other words, it really seems to be that you should extend seccomp() with the ability to attach filters to things that aren't syscall entry, e.g. file open.
I would also seriously consider doing a scaled-back Landlock variant first, with the intent of getting the main mechanism into the kernel. In particular, there are two big sources of complexity in Landlock. You need to deal with the API for managing bpf programs that filter various actions beyond just syscall entry, and you need to deal with giving those filters a way to deal with inodes, paths, etc. But you can do the former without the latter. For example, you could start with some Landlock-style filters on things that have nothing to do with files. For example, you could allow a filter for connecting to an abstract-namespace unix socket. Or you could have a hook for file_receive. (You couldn't meaningfully filter based on the *path* of the fd being received without adding all the path infrastructure, but you could fitler on the *type* of the fd being received.) Both of these add new sandboxing abilities that don't currently exist. In particular, you can't write a seccomp rule that prevents receiving an fd using recvmsg() right now unless you block cmsg entirely. And you can't write a filter that allows connecting to unix sockets by path without allowing abstract namespace sockets either.
If you split up Landlock like this then, once you got all the installation and management of filters down, you could submit patches to add all the path stuff and deal with that review separately.
What do you all think?
Mickaël Salaün
maintainerQuoted 96 lines · Andy Lutomirski
Quoted 86 lines · Mickaël Salaün
Hi,
This eight series is a major revamp of the Landlock design compared to the previous series [1]. This enables more flexibility and granularity of access control with file paths. It is now possible to enforce an access control according to a file hierarchy. Landlock uses the concept of inode and path to identify such hierarchy. In a way, it brings tools to program what is a file hierarchy.
There is now three types of Landlock hooks:
FS_WALK,FS_PICKandFS_GET. Each of them accepts a dedicated eBPF program, called a Landlock program. They can be chained to enforce a full access control according to a list of directories or files. The set of actions on a file is well defined (e.g. read, write, ioctl, append, lock, mount...) taking inspiration from the major Linux LSMs and some other access-controls like Capsicum. These program types are designed to be cache-friendly, which give room for optimizations in the future.The documentation patch contains some kernel documentation and explanations on how to use Landlock. The compiled documentation and a talk I gave at FOSDEM can be found here: https://landlock.io
This patch series can be found in the branch landlock-v8 in this repo:
https://github.com/landlock-lsm/linuxThere is still some minor issues with this patch series but it should demonstrate how powerful this design may be. One of these issues is that it is not a stackable LSM anymore, but the infrastructure management of security blobs should allow to stack it with other LSM [4].
This is the first step of the roadmap discussed at LPC [2]. While the intended final goal is to allow unprivileged users to use Landlock, this series allows only a process with global
CAP_SYS_ADMINto load and enforce a rule. This may help to get feedback and avoid unexpected behaviors.This series can be applied on top of bpf-next, commit
7d72637eb39f("Merge branch 'x86-jit'"). This can be tested withCONFIG_SECCOMP_FILTERandCONFIG_SECURITY_LANDLOCK. I would really appreciate constructive comments on the design and the code.# Landlock LSM
The goal of this new Linux Security Module (LSM) called Landlock is to allow any process, including unprivileged ones, to create powerful security sandboxes comparable to XNU Sandbox or OpenBSD Pledge. This kind of sandbox is expected to help mitigate the security impact of bugs or unexpected/malicious behaviors in user-space applications.
The approach taken is to add the minimum amount of code while still allowing the user-space application to create quite complex access rules. A dedicated security policy language such as the one used by SELinux, AppArmor and other major LSMs involves a lot of code and is usually permitted to only a trusted user (i.e. root). On the contrary, eBPF programs already exist and are designed to be safely loaded by unprivileged user-space.
This design does not seem too intrusive but is flexible enough to allow a powerful sandbox mechanism accessible by any process on Linux. The use of seccomp and Landlock is more suitable with the help of a user-space library (e.g. libseccomp) that could help to specify a high-level language to express a security policy instead of raw eBPF programs. Moreover, thanks to the LLVM front-end, it is quite easy to write an eBPF program with a subset of the C language.
# Frequently asked questions
## Why is seccomp-bpf not enough?
A seccomp filter can access only raw syscall arguments (i.e. the register values) which means that it is not possible to filter according to the value pointed to by an argument, such as a file pathname. As an embryonic Landlock version demonstrated, filtering at the syscall level is complicated (e.g. need to take care of race conditions). This is mainly because the access control checkpoints of the kernel are not at this high-level but more underneath, at the LSM-hook level. The LSM hooks are designed to handle this kind of checks. Landlock abstracts this approach to leverage the ability of unprivileged users to limit themselves.
Cf. section "What it isn't?" in
Documentation/prctl/seccomp_filter.txt## Why use the seccomp(2) syscall?
Quoted 8 lines
Landlock use the same semantic as seccomp to apply access rule restrictions. It add a new layer of security for the current process which is inherited by its children. It makes sense to use an unique access-restricting syscall (that should be allowed by seccomp filters) which can only drop privileges. Moreover, a Landlock rule could come from outside a process (e.g. passed through a UNIX socket). It is then useful to differentiate the creation/load of Landlock eBPF programs via bpf(2), from rule enforcement via seccomp(2).
Quoted 3 lines
This seems like a weak argument to me. Sure, this is a bit different from
seccomp(), and maybe shoving it into theseccomp()multiplexer is awkward, but surely thebpf()multiplexer is even less applicable.
I think using the seccomp syscall is fine, and everyone agreed on it.
Quoted 7 lines
But I think that you have more in common with
seccomp()than you're giving it credit for. With seccomp, you need to either preventptrace()of any more-privileged task or you need to filter to make sure you can't trace a more privileged program. With landlock, you need exactly the same thing. You have basically the sameno_new_privsconsiderations, etc.
Right, I did not mean to not give credit to seccomp at all.
Quoted 7 lines
Also, looking forward, I think you're going to want a bunch of the stuff that's under consideration as new seccomp features. Tycho is working on a "user notifier" feature for seccomp where, in addition to accepting, rejecting, or kicking to ptrace, you can send a message to the creator of the filter and wait for a reply. I think that Landlock will want exactly the same feature.
I don't think why this may be useful at all her. Landlock does not filter at the syscall level but handles kernel object and actions as does an LSM. That is the whole purpose of Landlock.
Quoted 4 lines
In other words, it really seems to be that you should extend
seccomp()with the ability to attach filters to things that aren't syscall entry, e.g. file open.
It seems that it is what I do… Not sure to understand you here.
Quoted 11 lines
I would also seriously consider doing a scaled-back Landlock variant first, with the intent of getting the main mechanism into the kernel. In particular, there are two big sources of complexity in Landlock. You need to deal with the API for managing bpf programs that filter various actions beyond just syscall entry, and you need to deal with giving those filters a way to deal with inodes, paths, etc. But you can do the former without the latter. For example, you could start with some Landlock-style filters on things that have nothing to do with files. For example, you could allow a filter for connecting to an abstract-namespace unix socket. Or you could have a hook for
Quoted 8 lines
file_receive. (You couldn't meaningfully filter based on the *path* of the fd being received without adding all the path infrastructure, but you could fitler on the *type* of the fd being received.) Both of these add new sandboxing abilities that don't currently exist. In particular, you can't write a seccomp rule that prevents receiving an fd usingrecvmsg()right now unless you block cmsg entirely. And you can't write a filter that allows connecting to unix sockets by path without allowing abstract namespace sockets either.
What you are proposing here seems like my previous patch series (v7). As it was suggested by Kees (and requested by future users), this patch series is able to handle file paths. This is a good thing because it highlight that this design can scale to evaluate complex objects (i.e. file paths), which was not the case for the previous patch series.
Quoted 7 lines
If you split up Landlock like this then, once you got all the installation and management of filters down, you could submit patches to add all the path stuff and deal with that review separately.
What do you all think?
I may be able to strip some parts for a first inclusion, but a complex use case like controlling access to files is an important use case.
Andy Lutomirski
reviewerQuoted 18 lines · Mickaël Salaün
Quoted 16 lines · Andy Lutomirski
Quoted 14 lines · Mickaël Salaün
Hi,
## Why use the seccomp(2) syscall?
Landlock use the same semantic as seccomp to apply access rule restrictions. It add a new layer of security for the current process which is inherited by its children. It makes sense to use an unique access-restricting syscall (that should be allowed by seccomp filters) which can only drop privileges. Moreover, a Landlock rule could come from outside a process (e.g. passed through a UNIX socket). It is then useful to differentiate the creation/load of Landlock eBPF programs via bpf(2), from rule enforcement via seccomp(2).
Quoted 6 lines
Quoted 3 lines
This seems like a weak argument to me. Sure, this is a bit different from
seccomp(), and maybe shoving it into theseccomp()multiplexer is awkward, but surely thebpf()multiplexer is even less applicable.I think using the seccomp syscall is fine, and everyone agreed on it.
Ah, sorry, I completely misread what you wrote. My apologies. You can disregard most of my email.
Quoted 9 lines
Quoted 8 lines
Also, looking forward, I think you're going to want a bunch of the stuff that's under consideration as new seccomp features. Tycho is working on a "user notifier" feature for seccomp where, in addition to accepting, rejecting, or kicking to ptrace, you can send a message to the creator of the filter and wait for a reply. I think that Landlock will want exactly the same feature.
Quoted 3 lines
I don't think why this may be useful at all her. Landlock does not filter at the syscall level but handles kernel object and actions as does an LSM. That is the whole purpose of Landlock.
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow moun() in general and I want to emulate certain mount() actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.
But using seccomp for this is indeed annoying. It would be nice to use Landlock's ability to filter based on the filesystem type, for example. So Tycho could write a Landlock rule like:
bool filter_mount(...)
{
if (path needs emulation)
call_user_notifier(); }
And it should work.
This means that, if both seccomp user notifiers and Landlock make it upstream, then there should probably be a way to have a user notifier bound to a seccomp filter and a set of landlock filters.
Mickaël Salaün
maintainerQuoted 42 lines · Andy Lutomirski
Quoted 18 lines · Mickaël Salaün
Quoted 16 lines · Andy Lutomirski
Quoted 14 lines · Mickaël Salaün
Hi,
## Why use the seccomp(2) syscall?
Landlock use the same semantic as seccomp to apply access rule restrictions. It add a new layer of security for the current process which is inherited by its children. It makes sense to use an unique access-restricting syscall (that should be allowed by seccomp filters) which can only drop privileges. Moreover, a Landlock rule could come from outside a process (e.g. passed through a UNIX socket). It is then useful to differentiate the creation/load of Landlock eBPF programs via bpf(2), from rule enforcement via seccomp(2).
Quoted 6 lines
Quoted 3 lines
This seems like a weak argument to me. Sure, this is a bit different from
seccomp(), and maybe shoving it into theseccomp()multiplexer is awkward, but surely thebpf()multiplexer is even less applicable.I think using the seccomp syscall is fine, and everyone agreed on it.
Ah, sorry, I completely misread what you wrote. My apologies. You can disregard most of my email.
Quoted 9 lines
Quoted 8 lines
Also, looking forward, I think you're going to want a bunch of the stuff that's under consideration as new seccomp features. Tycho is working on a "user notifier" feature for seccomp where, in addition to accepting, rejecting, or kicking to ptrace, you can send a message to the creator of the filter and wait for a reply. I think that Landlock will want exactly the same feature.
Quoted 3 lines
I don't think why this may be useful at all her. Landlock does not filter at the syscall level but handles kernel object and actions as does an LSM. That is the whole purpose of Landlock.
Quoted 6 lines
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow
moun()in general and I want to emulate certainmount()actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.
Well, I think this use case should be handled with something like LD_PRELOAD and a helper library. FYI, I did something like this:
https://github.com/stemjail/stemshim
Otherwise, we should think about enabling a process to (dynamically) extend/patch the vDSO (similar to LD_PRELOAD but at the syscall level and works with static binaries) for a subset of processes (the same way seccomp filters are inherited). It may be more powerful and flexible than extending the kernel/seccomp to patch (buggy?) userland.
Quoted 8 lines
But using seccomp for this is indeed annoying. It would be nice to use Landlock's ability to filter based on the filesystem type, for example. So Tycho could write a Landlock rule like:
bool
filter_mount(...)
{
if (path needs emulation)
Quoted 9 lines
call_user_notifier(); }And it should work.
This means that, if both seccomp user notifiers and Landlock make it upstream, then there should probably be a way to have a user notifier bound to a seccomp filter and a set of landlock filters.
Using seccomp filters and Landlock programs may be powerful. However, for this use case, I think a *post-syscall* vDSO-like (which could get some data returned by a Landlock program) may be much more flexible (with less kernel code). What is needed here is a way to know the kernel semantic (Landlock) and a way to patch userland without patching its code (vDSO-like).
Andy Lutomirski
reviewerQuoted 52 lines · Mickaël Salaün
Quoted 42 lines · Andy Lutomirski
Quoted 18 lines · Mickaël Salaün
Quoted 16 lines · Andy Lutomirski
Quoted 14 lines · Mickaël Salaün
Hi,
## Why use the seccomp(2) syscall?
Landlock use the same semantic as seccomp to apply access rule restrictions. It add a new layer of security for the current process which is inherited by its children. It makes sense to use an unique access-restricting syscall (that should be allowed by seccomp filters) which can only drop privileges. Moreover, a Landlock rule could come from outside a process (e.g. passed through a UNIX socket). It is then useful to differentiate the creation/load of Landlock eBPF programs via bpf(2), from rule enforcement via seccomp(2).
Quoted 6 lines
Quoted 3 lines
This seems like a weak argument to me. Sure, this is a bit different from
seccomp(), and maybe shoving it into theseccomp()multiplexer is awkward, but surely thebpf()multiplexer is even less applicable.I think using the seccomp syscall is fine, and everyone agreed on it.
Ah, sorry, I completely misread what you wrote. My apologies. You can disregard most of my email.
Quoted 9 lines
Quoted 8 lines
Also, looking forward, I think you're going to want a bunch of the stuff that's under consideration as new seccomp features. Tycho is working on a "user notifier" feature for seccomp where, in addition to accepting, rejecting, or kicking to ptrace, you can send a message to the creator of the filter and wait for a reply. I think that Landlock will want exactly the same feature.
Quoted 3 lines
I don't think why this may be useful at all her. Landlock does not filter at the syscall level but handles kernel object and actions as does an LSM. That is the whole purpose of Landlock.
Quoted 6 lines
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow
moun()in general and I want to emulate certainmount()actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.
Quoted 3 lines
Well, I think this use case should be handled with something like
LD_PRELOADand a helper library. FYI, I did something like this:
https://github.com/stemjail/stemshim
I doubt that will work for containers. Containers that use user namespaces and, for example, setuid programs aren't going to honor LD_PRELOAD.
Quoted 6 lines
Otherwise, we should think about enabling a process to (dynamically) extend/patch the vDSO (similar to
LD_PRELOADbut at the syscall level and works with static binaries) for a subset of processes (the same way seccomp filters are inherited). It may be more powerful and flexible than extending the kernel/seccomp to patch (buggy?) userland.
Egads!
Quoted 7 lines · Andy Lutomirski
Quoted 7 lines
Quoted 6 lines
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow
moun()in general and I want to emulate certainmount()actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.
Quoted 7 lines
Quoted 3 lines
Well, I think this use case should be handled with something like
LD_PRELOADand a helper library. FYI, I did something like this:
https://github.com/stemjail/stemshimI doubt that will work for containers. Containers that use user namespaces and, for example, setuid programs aren't going to honor
LD_PRELOAD.
Or anything that calls syscalls directly, like go programs.
Tycho
Mickaël Salaün
maintainerQuoted 12 lines · Tycho Andersen
Quoted 11 lines · Andy Lutomirski
Quoted 10 lines
Quoted 6 lines
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow
moun()in general and I want to emulate certainmount()actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.Well, I think this use case should be handled with something like
LD_PRELOADand a helper library. FYI, I did something like this:
https://github.com/stemjail/stemshim
Quoted 5 lines
Quoted 3 lines
I doubt that will work for containers. Containers that use user namespaces and, for example, setuid programs aren't going to honor
LD_PRELOAD.Or anything that calls syscalls directly, like go programs.
That's why the vDSO-like approach. Enforcing an access control is not the issue here, patching a buggy userland (without patching its code) is the issue isn't it?
As far as I remember, the main problem is to handle file descriptors while "emulating" the kernel behavior. This can be done with a "shim" code mapped in every processes. Chrome used something like this (in a previous sandbox mechanism) as a kind of emulation (with the current seccomp-bpf ). I think it should be doable to replace the (userland) emulation code with an IPC wrapper receiving file descriptors through UNIX socket.
Andy Lutomirski
reviewerQuoted 24 lines · Mickaël Salaün
Quoted 12 lines · Tycho Andersen
Quoted 11 lines · Andy Lutomirski
Quoted 10 lines
Quoted 6 lines
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow
moun()in general and I want to emulate certainmount()actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.Well, I think this use case should be handled with something like
LD_PRELOADand a helper library. FYI, I did something like this:
https://github.com/stemjail/stemshimQuoted 5 lines
Quoted 3 lines
I doubt that will work for containers. Containers that use user namespaces and, for example, setuid programs aren't going to honor
LD_PRELOAD.Or anything that calls syscalls directly, like go programs.
That's why the vDSO-like approach. Enforcing an access control is not the issue here, patching a buggy userland (without patching its code) is the issue isn't it?
Quoted 8 lines
As far as I remember, the main problem is to handle file descriptors while "emulating" the kernel behavior. This can be done with a "shim" code mapped in every processes. Chrome used something like this (in a previous sandbox mechanism) as a kind of emulation (with the current seccomp-bpf ). I think it should be doable to replace the (userland) emulation code with an IPC wrapper receiving file descriptors through UNIX socket.
Can you explain exactly what you mean by "vDSO-like"?
When a 64-bit program does a syscall, it just executes the SYSCALL instruction. The vDSO isn't involved at all. 32-bit programs usually go through the vDSO, but not always.
It could be possible to force-load a DSO into an entire container and rig up seccomp to intercept all SYSCALLs not originating from the DSO such that they merely redirect control to the DSO, but that seems quite messy.
Mickaël Salaün
maintainerQuoted 36 lines · Andy Lutomirski
Quoted 24 lines · Mickaël Salaün
Quoted 12 lines · Tycho Andersen
Quoted 11 lines · Andy Lutomirski
Quoted 10 lines
Quoted 6 lines
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow
moun()in general and I want to emulate certainmount()actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.Well, I think this use case should be handled with something like
LD_PRELOADand a helper library. FYI, I did something like this:
https://github.com/stemjail/stemshimQuoted 5 lines
Quoted 3 lines
I doubt that will work for containers. Containers that use user namespaces and, for example, setuid programs aren't going to honor
LD_PRELOAD.Or anything that calls syscalls directly, like go programs.
That's why the vDSO-like approach. Enforcing an access control is not the issue here, patching a buggy userland (without patching its code) is the issue isn't it?
Quoted 8 lines
As far as I remember, the main problem is to handle file descriptors while "emulating" the kernel behavior. This can be done with a "shim" code mapped in every processes. Chrome used something like this (in a previous sandbox mechanism) as a kind of emulation (with the current seccomp-bpf ). I think it should be doable to replace the (userland) emulation code with an IPC wrapper receiving file descriptors through UNIX socket.
Can you explain exactly what you mean by "vDSO-like"?
Quoted 8 lines
When a 64-bit program does a syscall, it just executes the SYSCALL instruction. The vDSO isn't involved at all. 32-bit programs usually go through the vDSO, but not always.
It could be possible to force-load a DSO into an entire container and rig up seccomp to intercept all SYSCALLs not originating from the DSO such that they merely redirect control to the DSO, but that seems quite messy.
vDSO is a code mapped for all processes. As you said, these processes may use it or not. What I was thinking about is to use the same concept, i.e. map a "shim" code into each processes pertaining to a particular hierarchy (the same way seccomp filters are inherited across processes). With a seccomp filter matching some syscall (e.g. mount, open), it is possible to jump back to the shim code thanks to SECCOMP_RET_TRAP. This shim code should then be able to emulate/patch what is needed, even faking a file opening by receiving a file descriptor through a UNIX socket. As did the Chrome sandbox, the seccomp filter may look at the calling address to allow the shim code to call syscalls without being catched, if needed. However, relying on SIGSYS may not fit with arbitrary code. Using a new SECCOMP_RET_EMULATE (?) may be used to jump to a specific process address, to emulate the syscall in an easier way than only relying on a {c,e}BPF program.
Quoted 47 lines · Mickaël Salaün
Quoted 36 lines · Andy Lutomirski
Quoted 24 lines · Mickaël Salaün
Quoted 12 lines · Tycho Andersen
Quoted 11 lines · Andy Lutomirski
Quoted 10 lines
Quoted 6 lines
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow
moun()in general and I want to emulate certainmount()actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.Well, I think this use case should be handled with something like
LD_PRELOADand a helper library. FYI, I did something like this:
https://github.com/stemjail/stemshimQuoted 5 lines
Quoted 3 lines
I doubt that will work for containers. Containers that use user namespaces and, for example, setuid programs aren't going to honor
LD_PRELOAD.Or anything that calls syscalls directly, like go programs.
That's why the vDSO-like approach. Enforcing an access control is not the issue here, patching a buggy userland (without patching its code) is the issue isn't it?
Quoted 8 lines
As far as I remember, the main problem is to handle file descriptors while "emulating" the kernel behavior. This can be done with a "shim" code mapped in every processes. Chrome used something like this (in a previous sandbox mechanism) as a kind of emulation (with the current seccomp-bpf ). I think it should be doable to replace the (userland) emulation code with an IPC wrapper receiving file descriptors through UNIX socket.
Can you explain exactly what you mean by "vDSO-like"?
Quoted 8 lines
When a 64-bit program does a syscall, it just executes the SYSCALL instruction. The vDSO isn't involved at all. 32-bit programs usually go through the vDSO, but not always.
It could be possible to force-load a DSO into an entire container and rig up seccomp to intercept all SYSCALLs not originating from the DSO such that they merely redirect control to the DSO, but that seems quite messy.
Quoted 15 lines
vDSO is a code mapped for all processes. As you said, these processes may use it or not. What I was thinking about is to use the same concept, i.e. map a "shim" code into each processes pertaining to a particular hierarchy (the same way seccomp filters are inherited across processes). With a seccomp filter matching some syscall (e.g. mount, open), it is possible to jump back to the shim code thanks to
SECCOMP_RET_TRAP. This shim code should then be able to emulate/patch what is needed, even faking a file opening by receiving a file descriptor through a UNIX socket. As did the Chrome sandbox, the seccomp filter may look at the calling address to allow the shim code to call syscalls without being catched, if needed. However, relying on SIGSYS may not fit with arbitrary code. Using a newSECCOMP_RET_EMULATE(?) may be used to jump to a specific process address, to emulate the syscall in an easier way than only relying on a {c,e}BPF program.
This could indeed be done, but I think that Tycho's approach is much cleaner and probably faster.
Mickaël Salaün
maintainerv8 cover Landlock LSM: Toward unprivileged sandboxing
Quoted 64 lines · Andy Lutomirski
Quoted 47 lines · Mickaël Salaün
Quoted 36 lines · Andy Lutomirski
Quoted 24 lines · Mickaël Salaün
Quoted 12 lines · Tycho Andersen
Quoted 11 lines · Andy Lutomirski
Quoted 10 lines
Quoted 6 lines
Suppose I'm writing a container manager. I want to run "mount" in the container, but I don't want to allow
moun()in general and I want to emulate certainmount()actions. I can write a filter that catches mount using seccomp and calls out to the container manager for help. This isn't theoretical -- Tycho wants *exactly* this use case to be supported.Well, I think this use case should be handled with something like
LD_PRELOADand a helper library. FYI, I did something like this:
https://github.com/stemjail/stemshimQuoted 5 lines
Quoted 3 lines
I doubt that will work for containers. Containers that use user namespaces and, for example, setuid programs aren't going to honor
LD_PRELOAD.Or anything that calls syscalls directly, like go programs.
That's why the vDSO-like approach. Enforcing an access control is not the issue here, patching a buggy userland (without patching its code) is the issue isn't it?
Quoted 8 lines
As far as I remember, the main problem is to handle file descriptors while "emulating" the kernel behavior. This can be done with a "shim" code mapped in every processes. Chrome used something like this (in a previous sandbox mechanism) as a kind of emulation (with the current seccomp-bpf ). I think it should be doable to replace the (userland) emulation code with an IPC wrapper receiving file descriptors through UNIX socket.
Can you explain exactly what you mean by "vDSO-like"?
Quoted 8 lines
When a 64-bit program does a syscall, it just executes the SYSCALL instruction. The vDSO isn't involved at all. 32-bit programs usually go through the vDSO, but not always.
It could be possible to force-load a DSO into an entire container and rig up seccomp to intercept all SYSCALLs not originating from the DSO such that they merely redirect control to the DSO, but that seems quite messy.
Quoted 15 lines
vDSO is a code mapped for all processes. As you said, these processes may use it or not. What I was thinking about is to use the same concept, i.e. map a "shim" code into each processes pertaining to a particular hierarchy (the same way seccomp filters are inherited across processes). With a seccomp filter matching some syscall (e.g. mount, open), it is possible to jump back to the shim code thanks to
SECCOMP_RET_TRAP. This shim code should then be able to emulate/patch what is needed, even faking a file opening by receiving a file descriptor through a UNIX socket. As did the Chrome sandbox, the seccomp filter may look at the calling address to allow the shim code to call syscalls without being catched, if needed. However, relying on SIGSYS may not fit with arbitrary code. Using a newSECCOMP_RET_EMULATE(?) may be used to jump to a specific process address, to emulate the syscall in an easier way than only relying on a {c,e}BPF program.
Quoted 3 lines
This could indeed be done, but I think that Tycho's approach is much cleaner and probably faster.
I like it too but how does this handle file descriptors?
Hi Mickaël,
Quoted 16 lines · Mickaël Salaün
Quoted 16 lines
Quoted 15 lines
vDSO is a code mapped for all processes. As you said, these processes may use it or not. What I was thinking about is to use the same concept, i.e. map a "shim" code into each processes pertaining to a particular hierarchy (the same way seccomp filters are inherited across processes). With a seccomp filter matching some syscall (e.g. mount, open), it is possible to jump back to the shim code thanks to
SECCOMP_RET_TRAP. This shim code should then be able to emulate/patch what is needed, even faking a file opening by receiving a file descriptor through a UNIX socket. As did the Chrome sandbox, the seccomp filter may look at the calling address to allow the shim code to call syscalls without being catched, if needed. However, relying on SIGSYS may not fit with arbitrary code. Using a newSECCOMP_RET_EMULATE(?) may be used to jump to a specific process address, to emulate the syscall in an easier way than only relying on a {c,e}BPF program.
Quoted 5 lines
Quoted 3 lines
This could indeed be done, but I think that Tycho's approach is much cleaner and probably faster.
I like it too but how does this handle file descriptors?
I think it could be done fairly simply, the most complicated part is probably designing an API that doesn't suck. But the basic idea would be:
struct seccomp_notif_resp {
__u64 id;
__s32 error;
__s64 val;
__s32 fd;
};if the handler responds with fd >= 0, we grab the tracer's fd, duplicate it, and install it somewhere in the tracee's fd table. Since things like socket() will want to return the fd number as its installed and the handler doesn't know that, we'll probably want some way to indicate that the kernel should return this value. We could either mandate that if fd >= 0, that's the value that will be returned from the syscall, or add another flag that says "no, install the fd, but really return what's in val instead).
I guess we can't mandate that we return fd, because e.g. netlink sockets can sometimes return fds as part of the netlink messages, and not as the return value from the syscall.
Tycho