Landlock LSM
Subsystems (10)
Mickaël Salaün
maintainerv12 cover Landlock LSM
Hi,
Following the previous series [1], this twelfth series mainly rework the domain management in response to Serge E. Hallyn's review. Some minor fixes are also included.
This is the first step of the roadmap discussed at LPC [2]. While the intended final goal is to allow unprivileged (or non-root) 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 e93d99180abd ("selftests/bpf: Restore $(OUTPUT)/test_stub.o rule"). This can be tested with CONFIG_BPF_SYSCALL, CONFIG_SECCOMP_FILTER and CONFIG_SECURITY_LANDLOCK. This patch series can be found in a Git repository here:
https://github.com/landlock-lsm/linux/commits/landlock-v11
I would really appreciate constructive comments on the design and the code.
# Landlock LSM
Landlock is a stackable LSM [3] intended to be used as a low-level framework to build custom access-control/audit systems or safe endpoint security agents. There is currently one Landlock hook dedicated to check ptrace(2). This hook accepts a dedicated eBPF program, called a Landlock program, which can currently compare its position in the hierarchy of similar programs tied to other processes. This enables to enforce programmatic scoped ptrace restrictions.
The final 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, FreeBSD Capsicum or OpenBSD Pledge (which could be implemented with Landlock). This kind of sandbox is expected to help mitigate the security impact of bugs or unexpected/malicious behaviors in user-space applications.
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.
The documentation patch contains some kernel documentation, explanations on how to use Landlock and a FAQ. The compiled documentation and some talks can be found here: https://landlock.io
# 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 (i.e. seccomp-object), 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?" inDocumentation/userspace-api/seccomp_filter.rst
## 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 v11
* rework domain management
* minor fixes
# Changes since v10
* remove all the file system related features: program types, inode map and expected_attach_triggers
* replace the static ptrace security policy with a new and simpler ptrace program (attached) type and a task_landlock_ptrace_ancestor() eBPF helper
* do not rely on seccomp internal structure but use stacked credentials insdead
* extend ptrace tests
* add more documentation
* split and rename files/patches
* miscellaneous fixes
Previous changes can be found in a previous cover-letter [4].
[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://lore.kernel.org/lkml/[email protected]/
[3] https://lore.kernel.org/lkml/[email protected]/
[4] https://lore.kernel.org/lkml/[email protected]/
Regards,
Mickaël Salaün (7):
bpf,landlock: Define an eBPF program type for Landlock hooks
landlock: Add the management of domains landlock,seccomp: Load Landlock programs per process hierarchy
landlock: Add ptrace LSM hooks
bpf,landlock: Add task_landlock_ptrace_ancestor() helper bpf,landlock: Add tests for the Landlock ptrace program type
landlock: Add user and kernel documentation for Landlock
Documentation/security/index.rst | 1 + Documentation/security/landlock/index.rst | 22 ++ Documentation/security/landlock/kernel.rst | 139 ++++++++++++ Documentation/security/landlock/user.rst | 142 ++++++++++++ MAINTAINERS | 9 + include/linux/bpf.h | 3 + include/linux/bpf_types.h | 3 + include/linux/landlock.h | 25 ++ include/linux/lsm_hooks.h | 1 + include/uapi/linux/bpf.h | 23 +- include/uapi/linux/landlock.h | 39 ++++ include/uapi/linux/seccomp.h | 1 + kernel/bpf/syscall.c | 9 + kernel/bpf/verifier.c | 11 + kernel/seccomp.c | 4 + scripts/bpf_helpers_doc.py | 1 + security/Kconfig | 1 + security/Makefile | 2 + security/landlock/Kconfig | 19 ++ security/landlock/Makefile | 6 + security/landlock/bpf_ptrace.c | 98 ++++++++ security/landlock/bpf_ptrace.h | 17 ++ security/landlock/bpf_run.c | 62 +++++ security/landlock/bpf_run.h | 25 ++ security/landlock/bpf_verify.c | 87 +++++++ security/landlock/common.h | 84 +++++++ security/landlock/domain_manage.c | 173 ++++++++++++++ security/landlock/domain_manage.h | 23 ++ security/landlock/domain_syscall.c | 87 +++++++ security/landlock/hooks_cred.c | 47 ++++ security/landlock/hooks_cred.h | 14 ++ security/landlock/hooks_ptrace.c | 114 ++++++++++ security/landlock/hooks_ptrace.h | 19 ++ security/landlock/init.c | 32 +++ security/security.c | 15 ++ tools/include/uapi/linux/bpf.h | 23 +- tools/include/uapi/linux/landlock.h | 22 ++ tools/lib/bpf/libbpf_probes.c | 3 + tools/testing/selftests/bpf/config | 3 + tools/testing/selftests/bpf/test_verifier.c | 1 + .../testing/selftests/bpf/verifier/landlock.c | 56 +++++ tools/testing/selftests/landlock/.gitignore | 5 + tools/testing/selftests/landlock/Makefile | 27 +++ tools/testing/selftests/landlock/config | 5 + tools/testing/selftests/landlock/test.h | 48 ++++ tools/testing/selftests/landlock/test_base.c | 24 ++ .../testing/selftests/landlock/test_ptrace.c | 214 ++++++++++++++++++ 47 files changed, 1787 insertions(+), 2 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 security/landlock/Kconfig create mode 100644 security/landlock/Makefile create mode 100644 security/landlock/bpf_ptrace.c create mode 100644 security/landlock/bpf_ptrace.h create mode 100644 security/landlock/bpf_run.c create mode 100644 security/landlock/bpf_run.h create mode 100644 security/landlock/bpf_verify.c create mode 100644 security/landlock/common.h create mode 100644 security/landlock/domain_manage.c create mode 100644 security/landlock/domain_manage.h create mode 100644 security/landlock/domain_syscall.c create mode 100644 security/landlock/hooks_cred.c create mode 100644 security/landlock/hooks_cred.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 tools/include/uapi/linux/landlock.h create mode 100644 tools/testing/selftests/bpf/verifier/landlock.c create mode 100644 tools/testing/selftests/landlock/.gitignore create mode 100644 tools/testing/selftests/landlock/Makefile create mode 100644 tools/testing/selftests/landlock/config 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_ptrace.c
Signature · 1 line
2.23.0
Mickaël Salaün
maintainerPATCH v12 1/7 bpf,landlock: Define an eBPF program type for Landlock hooks
Add a new type of eBPF program used by Landlock hooks. The goal of this type of program is to accept or deny a requested access from userspace to a kernel object (e.g. process). This will be more useful with the next commit adding a new eBPF helper.
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 v10:
* replace file system program types with a (simpler) ptrace program type
* add an eBPF task pointer type
* split files
Changes since v9:
* handle inode put and map put, which fix unmount (reported by Al Viro)
* replace subtype with expected_attach_type and expected_attach_triggers
* check eBPF program return code
Changes since v8:
* Remove the chaining concept from the eBPF program contexts (chain and cookie). We need to keep these subtypes this way to be able to make them evolve, though.
* remove bpf_landlock_put_extra() because there is no more a "previous" field to free (for now)
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 | 8 ++++ include/linux/bpf.h | 1 + include/linux/bpf_types.h | 3 ++ include/uapi/linux/bpf.h | 2 + include/uapi/linux/landlock.h | 39 ++++++++++++++++ kernel/bpf/syscall.c | 9 ++++ kernel/bpf/verifier.c | 7 +++ security/Kconfig | 1 + security/Makefile | 2 + security/landlock/Kconfig | 19 ++++++++ security/landlock/Makefile | 4 ++ security/landlock/bpf_ptrace.c | 30 ++++++++++++ security/landlock/bpf_ptrace.h | 17 +++++++ security/landlock/bpf_verify.c | 83 ++++++++++++++++++++++++++++++++++ security/landlock/common.h | 30 ++++++++++++ 15 files changed, 255 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/bpf_ptrace.c create mode 100644 security/landlock/bpf_ptrace.h create mode 100644 security/landlock/bpf_verify.c create mode 100644 security/landlock/common.h
MAINTAINERS +8 -0
@@ -9146,6 +9146,14 @@ F: net/core/skmsg.c F: net/core/sock_map.c F: net/ipv4/tcp_bpf.c +LANDLOCK SECURITY MODULE +M: Mickaël Salaün <[email protected]> +S: Supported +F: include/uapi/linux/landlock.h +F: security/landlock/ +K: landlock +K: LANDLOCK + LANTIQ / INTEL Ethernet drivers M: Hauke Mehrtens <[email protected]> L: [email protected]
include/linux/bpf.h +1 -0
@@ -291,6 +291,7 @@ enum bpf_reg_type {PTR_TO_TP_BUFFER ,/* reg points to a writable raw tp's buffer */ PTR_TO_XDP_SOCK ,/* reg points to struct xdp_sock */ PTR_TO_BTF_ID ,/* reg points to kernel struct */ + PTR_TO_TASK, /* reg points to struct task_struct */ };/* The information passed from prog-specific *_is_valid_access
include/linux/bpf_types.h +3 -0
@@ -38,6 +38,9 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_LIRC_MODE2, lirc_mode2)#ifdef CONFIG_INET BPF_PROG_TYPE(BPF_PROG_TYPE_SK_REUSEPORT, sk_reuseport)#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 +2 -0
@@ -173,6 +173,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_CGROUP_SYSCTL ,BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE ,BPF_PROG_TYPE_CGROUP_SOCKOPT , + BPF_PROG_TYPE_LANDLOCK_HOOK, }; enum bpf_attach_type {
@@ -199,6 +200,7 @@ enum bpf_attach_type {BPF_CGROUP_UDP6_RECVMSG ,BPF_CGROUP_GETSOCKOPT ,BPF_CGROUP_SETSOCKOPT , +BPF_LANDLOCK_PTRACE , __MAX_BPF_ATTACH_TYPE };
include/uapi/linux/landlock.h new file +39 -0
@@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* +* Landlock - UAPI headers +* +* Copyright © 2017-2019 Mickaël Salaün <[email protected]> +* Copyright © 2018-2019 ANSSI +*/ + +#ifndef _UAPI__LINUX_LANDLOCK_H__ +#define _UAPI__LINUX_LANDLOCK_H__ + +#include <linux/types.h> + +/** +* DOC: landlock_ret +* +* The return value of a landlock program is a bitmask that can allow or deny +* the action for which the program is run. +* +* In the future, this could be used to trigger an audit event as well. +* +* - %LANDLOCK_RET_ALLOW +* - %LANDLOCK_RET_DENY +*/ +#define LANDLOCK_RET_ALLOW 0 +#define LANDLOCK_RET_DENY 1 + +/** +* struct landlock_context_ptrace - context accessible to BPF_LANDLOCK_PTRACE +* +* @tracer: pointer to the task requesting to debug @tracee +* @tracee: pointer to the task being debugged +*/ +struct landlock_context_ptrace { +__u64 tracer; +__u64 tracee; +}; + +#endif /* _UAPI__LINUX_LANDLOCK_H__ */
kernel/bpf/syscall.c +9 -0
@@ -1621,6 +1621,15 @@ bpf_prog_load_check_attach(enum bpf_prog_type prog_type,default :return -EINVAL ; } +#ifdef CONFIG_SECURITY_LANDLOCK +case BPF_PROG_TYPE_LANDLOCK_HOOK : +switch (expected_attach_type) { +case BPF_LANDLOCK_PTRACE : +return 0 ; +default : +return -EINVAL ; + } +#endif default :return 0 ; }
kernel/bpf/verifier.c +7 -0
@@ -421,6 +421,7 @@ static const char * const reg_type_str[] = { [PTR_TO_TP_BUFFER] = "tp_buffer", [PTR_TO_XDP_SOCK] = "xdp_sock", [PTR_TO_BTF_ID] = "ptr_", + [PTR_TO_TASK] = "task", };static char slot_type_char[] = {
@@ -1878,6 +1879,7 @@ static bool is_spillable_regtype(enum bpf_reg_type type)case PTR_TO_TCP_SOCK :case PTR_TO_TCP_SOCK_OR_NULL :case PTR_TO_XDP_SOCK : +case PTR_TO_TASK :return true;default :return false;
@@ -2600,6 +2602,9 @@ static int check_ptr_alignment(struct bpf_verifier_env *env,case PTR_TO_XDP_SOCK : pointer_desc ="xdp_sock " ;break ; +case PTR_TO_TASK : + pointer_desc ="task " ; +break ;default :break ; }
@@ -4527,6 +4532,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,case PTR_TO_TCP_SOCK :case PTR_TO_TCP_SOCK_OR_NULL :case PTR_TO_XDP_SOCK : +case PTR_TO_TASK :verbose (env,"R%d pointer arithmetic on %s prohibited\n" , dst, reg_type_str[ptr_reg->type]);return -EACCES ;
@@ -6278,6 +6284,7 @@ static int check_return_code(struct bpf_verifier_env *env)case BPF_PROG_TYPE_CGROUP_DEVICE :case BPF_PROG_TYPE_CGROUP_SYSCTL :case BPF_PROG_TYPE_CGROUP_SOCKOPT : +case BPF_PROG_TYPE_LANDLOCK_HOOK :break ;default :return 0 ;
security/Kconfig +1 -0
@@ -238,6 +238,7 @@ source "security/loadpin/Kconfig" source "security/yama/Kconfig" source "security/safesetid/Kconfig" source "security/lockdown/Kconfig" +source "security/landlock/Kconfig" source "security/integrity/Kconfig"
security/Makefile +2 -0
@@ -12,6 +12,7 @@ subdir-$(CONFIG_SECURITY_YAMA) += yama subdir-$(CONFIG_SECURITY_LOADPIN) += loadpin subdir-$(CONFIG_SECURITY_SAFESETID) += safesetid subdir-$(CONFIG_SECURITY_LOCKDOWN_LSM) += lockdown +subdir-$(CONFIG_SECURITY_LANDLOCK) += landlock # always enable default capabilities obj-y += commoncap.o
@@ -29,6 +30,7 @@ obj-$(CONFIG_SECURITY_YAMA) += yama/ obj-$(CONFIG_SECURITY_LOADPIN) += loadpin/ obj-$(CONFIG_SECURITY_SAFESETID) += safesetid/ obj-$(CONFIG_SECURITY_LOCKDOWN_LSM) += lockdown/ +obj-$(CONFIG_SECURITY_LANDLOCK) += landlock/ obj-$(CONFIG_CGROUP_DEVICE) += device_cgroup.o # Object integrity file lists
security/landlock/Kconfig new file +19 -0
@@ -0,0 +1,19 @@ +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) or log some + actions. The security policy is a set of eBPF programs, dedicated to + allow or deny a list of actions on specific kernel objects (e.g. + process). + + 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 +4 -0
@@ -0,0 +1,4 @@ +obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o + +landlock-y := \ + bpf_verify.o bpf_ptrace.o
security/landlock/bpf_ptrace.c new file +30 -0
@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Landlock LSM - eBPF ptrace +* +* Copyright © 2017-2019 Mickaël Salaün <[email protected]> +* Copyright © 2019 ANSSI +*/ + +#include <linux/bpf.h> +#include <uapi/linux/landlock.h> + +#include "bpf_ptrace.h" + +bool landlock_is_valid_access_ptrace (int off,enum bpf_access_type type, +enum bpf_reg_type *reg_type,int *max_size) +{ +if (type !=BPF_READ ) +return false; + +switch (off) { +case offsetof(struct landlock_context_ptrace , tracer): +/* fall through */ +case offsetof(struct landlock_context_ptrace , tracee): + *reg_type =PTR_TO_TASK ; + *max_size =sizeof (u64); +return true; +default : +return false; + } +}
security/landlock/bpf_ptrace.h new file +17 -0
@@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Landlock LSM - eBPF ptrace headers +* +* Copyright © 2017-2019 Mickaël Salaün <[email protected]> +* Copyright © 2019 ANSSI +*/ + +#ifndef _SECURITY_LANDLOCK_BPF_PTRACE_H +#define _SECURITY_LANDLOCK_BPF_PTRACE_H + +#include <linux/bpf.h> + +bool landlock_is_valid_access_ptrace (int off,enum bpf_access_type type, +enum bpf_reg_type *reg_type,int *max_size); + +#endif /* _SECURITY_LANDLOCK_BPF_PTRACE_H */
security/landlock/bpf_verify.c new file +83 -0
83 lines not on this page · raw message
security/landlock/common.h new file +30 -0
@@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Landlock LSM - private headers +* +* Copyright © 2016-2019 Mickaël Salaün <[email protected]> +* Copyright © 2018-2019 ANSSI +*/ + +#ifndef _SECURITY_LANDLOCK_COMMON_H +#define _SECURITY_LANDLOCK_COMMON_H + +#include <linux/bpf.h> +#include <linux/filter.h> + +enum landlock_hook_type { +LANDLOCK_HOOK_PTRACE =1 , +}; + +static inline enum landlock_hook_type get_hook_type (const struct bpf_prog *prog) +{ +switch (prog->expected_attach_type) { +case BPF_LANDLOCK_PTRACE : +return LANDLOCK_HOOK_PTRACE ; +default : +WARN_ON (1 ); +return BPF_LANDLOCK_PTRACE ; + } +} + +#endif /* _SECURITY_LANDLOCK_COMMON_H */
Signature · 1 line
2.23.0
Mickaël Salaün
maintainerPATCH v12 2/7 landlock: Add the management of domains
In reply to Mickaël SalaünA Landlock domain is a set of eBPF programs. There is a list for each different program types that can be run on a specific Landlock hook (e.g. ptrace). A domain is tied to a set of subjects (i.e. tasks). A Landlock program should not try (nor be able) to infer which subject is currently enforced, but to have a unique security policy for all subjects tied to the same domain. This make the reasoning much easier and help avoid pitfalls.
The next commits tie a domain to a task's credentials thanks to seccomp(2), but we could use cgroups or a security file-system to enforce a sysadmin-defined policy .
---
Changes since v11:
* remove old code from previous refactoring (removing the program chaining concept) and simplify program prepending (reported by Serge E. Hallyn):
* simplify landlock_prepend_prog() and merge it with store_landlock_prog()
* add new_prog_list() and rework new_landlock_domain()
* remove the extra page allocation checks, only rely on the eBPF program checks
* replace the -EINVAL for the duplicate program check with the -EEXIST
Changes since v10:
* rename files and names to clearly define a domain
* create a standalone patch to ease review
--- security/landlock/Makefile | 3 +- security/landlock/common.h | 38 +++++++ security/landlock/domain_manage.c | 173 ++++++++++++++++++++++++++++++ security/landlock/domain_manage.h | 23 ++++ 4 files changed, 236 insertions(+), 1 deletion(-) create mode 100644 security/landlock/domain_manage.c create mode 100644 security/landlock/domain_manage.h
security/landlock/Makefile +2 -1
@@ -1,4 +1,5 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := \ - bpf_verify.o bpf_ptrace.o + bpf_verify.o bpf_ptrace.o \ + domain_manage.o
security/landlock/common.h +38 -0
@@ -11,11 +11,49 @@#include <linux/bpf.h> #include <linux/filter.h> +#include <linux/refcount.h> enum landlock_hook_type {LANDLOCK_HOOK_PTRACE =1 , }; +#define _LANDLOCK_HOOK_LAST LANDLOCK_HOOK_PTRACE + +struct landlock_prog_list { +struct landlock_prog_list *prev; +struct bpf_prog *prog; +refcount_t usage; +}; + +/** +* struct landlock_domain - Landlock programs enforced on a set of tasks +* +* When prepending a new program, if &struct landlock_domain is shared with +* other tasks, then duplicate it and prepend the program to this new &struct +* landlock_domain. +* +* @usage: reference count to manage the object lifetime. When a task needs to +* add Landlock programs and if @usage is greater than 1, then the +* task must duplicate &struct landlock_domain to not change the +* children's programs as well. +* @programs: array of non-NULL &struct landlock_prog_list pointers +*/ +struct landlock_domain { +struct landlock_prog_list *programs[_LANDLOCK_HOOK_LAST]; +refcount_t usage; +}; + +/** +* get_hook_index - get an index for the programs of struct landlock_prog_set +* +* @type: a Landlock hook type +*/ +static inline size_t get_hook_index (enum landlock_hook_type type) +{ +/* type ID > 0 for loaded programs */ +return type -1 ; +} +static inline enum landlock_hook_type get_hook_type (const struct bpf_prog *prog) {switch (prog->expected_attach_type) {
security/landlock/domain_manage.c new file +173 -0
173 lines not on this page · raw message
security/landlock/domain_manage.h new file +23 -0
@@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Landlock LSM - domain management headers +* +* Copyright © 2016-2019 Mickaël Salaün <[email protected]> +* Copyright © 2018-2019 ANSSI +*/ + +#ifndef _SECURITY_LANDLOCK_DOMAIN_MANAGE_H +#define _SECURITY_LANDLOCK_DOMAIN_MANAGE_H + +#include <linux/filter.h> + +#include "common.h" + +void landlock_get_domain (struct landlock_domain *dom); +void landlock_put_domain (struct landlock_domain *dom); + +struct landlock_domain *landlock_prepend_prog ( +struct landlock_domain *current_domain, +struct bpf_prog *prog); + +#endif /* _SECURITY_LANDLOCK_DOMAIN_MANAGE_H */
Signature · 1 line
2.23.0
Mickaël Salaün
maintainerPATCH v12 3/7 landlock,seccomp: Load 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 programs.
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 binary 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.
The next commit adds the LSM hooks to enforce the memory protection programs on the appropriate process hierarchies.
---
Changes since v11:
* fix build of seccomp without Landlock (reported by kbuild test robot)
Changes since v10:
* rewrite the Landlock program attaching mechanisme to not rely on internal seccomp structures but only on the (LSM-stacked) task's credentials:
* make the use of seccomp (and task's credentials) optional if not relying on its syscall, which may be useful for domains defined by other means (e.g. cgroups or system-wide thanks to a dedicated securityfs)
Changes since v9:
* replace subtype with expected_attach_type and expected_attach_triggers
Changes since v8:
* Remove the chaining concept from the eBPF program contexts (chain and cookie). We need to keep these subtypes this way to be able to make them evolve, though.
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
--- MAINTAINERS | 1 + include/linux/landlock.h | 25 +++++++++ include/linux/lsm_hooks.h | 1 + include/uapi/linux/seccomp.h | 1 + kernel/seccomp.c | 4 ++ security/landlock/Makefile | 5 +- security/landlock/common.h | 16 ++++++ security/landlock/domain_syscall.c | 87 ++++++++++++++++++++++++++++++ security/landlock/hooks_cred.c | 47 ++++++++++++++++ security/landlock/hooks_cred.h | 14 +++++ security/landlock/init.c | 30 +++++++++++ security/security.c | 15 ++++++ 12 files changed, 244 insertions(+), 2 deletions(-) create mode 100644 include/linux/landlock.h create mode 100644 security/landlock/domain_syscall.c create mode 100644 security/landlock/hooks_cred.c create mode 100644 security/landlock/hooks_cred.h create mode 100644 security/landlock/init.c
MAINTAINERS +1 -0
@@ -9149,6 +9149,7 @@ F: net/ipv4/tcp_bpf.c LANDLOCK SECURITY MODULE M: Mickaël Salaün <[email protected]> S: Supported +F: include/linux/landlock.h F: include/uapi/linux/landlock.h F: security/landlock/ K: landlock
include/linux/landlock.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Landlock LSM - public kernel headers +* +* Copyright © 2016-2019 Mickaël Salaün <[email protected]> +* Copyright © 2018-2019 ANSSI +*/ + +#ifndef _LINUX_LANDLOCK_H +#define _LINUX_LANDLOCK_H + +#include <linux/errno.h> + +#if defined(CONFIG_SECCOMP_FILTER ) && defined(CONFIG_SECURITY_LANDLOCK ) +extern int landlock_seccomp_prepend_prog (unsigned int flags, +const int __user *user_bpf_fd); +#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 ; +} +#endif /* CONFIG_SECCOMP_FILTER && CONFIG_SECURITY_LANDLOCK */ + +#endif /* _LINUX_LANDLOCK_H */
include/linux/lsm_hooks.h +1 -0
@@ -2106,6 +2106,7 @@ extern void security_add_hooks(struct security_hook_list *hooks, int count,enum lsm_order {LSM_ORDER_FIRST =-1 ,/* This is only for capabilities. */ LSM_ORDER_MUTABLE =0 , +LSM_ORDER_LAST =1 ,/* potentially-unprivileged LSM */ };struct lsm_info {
include/uapi/linux/seccomp.h +1 -0
@@ -16,6 +16,7 @@#define SECCOMP_SET_MODE_FILTER 1#define SECCOMP_GET_ACTION_AVAIL 2#define SECCOMP_GET_NOTIF_SIZES 3 +#define SECCOMP_PREPEND_LANDLOCK_PROG 4/* Valid flags for SECCOMP_SET_MODE_FILTER */ #define SECCOMP_FILTER_FLAG_TSYNC (1UL << 0)
kernel/seccomp.c +4 -0
@@ -19,6 +19,7 @@#include <linux/compat.h> #include <linux/coredump.h> #include <linux/kmemleak.h> +#include <linux/landlock.h> #include <linux/nospec.h> #include <linux/prctl.h> #include <linux/sched.h>
@@ -1397,6 +1398,9 @@ static long do_seccomp(unsigned int op, unsigned int flags,return -EINVAL ;return seccomp_get_notif_sizes (uargs); +case SECCOMP_PREPEND_LANDLOCK_PROG : +return landlock_seccomp_prepend_prog (flags, + (const int __user *)uargs);default :return -EINVAL ; }
security/landlock/Makefile +3 -2
@@ -1,5 +1,6 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o -landlock-y := \ +landlock-y := init.o \ bpf_verify.o bpf_ptrace.o \ - domain_manage.o + domain_manage.o domain_syscall.o \ + hooks_cred.o
security/landlock/common.h +16 -0
@@ -10,9 +10,15 @@#define _SECURITY_LANDLOCK_COMMON_H#include <linux/bpf.h> +#include <linux/cred.h> #include <linux/filter.h> +#include <linux/lsm_hooks.h> #include <linux/refcount.h> +#define LANDLOCK_NAME "landlock" + +extern struct lsm_blob_sizes landlock_blob_sizes; +enum landlock_hook_type {LANDLOCK_HOOK_PTRACE =1 , };
@@ -43,6 +49,16 @@ struct landlock_domain {refcount_t usage; }; +struct landlock_cred_security { +struct landlock_domain *domain; +}; + +static inline struct landlock_cred_security *landlock_cred ( +const struct cred *cred) +{ +return cred->security + landlock_blob_sizes.lbs_cred; +} +/** * get_hook_index - get an index for the programs of struct landlock_prog_set *
security/landlock/domain_syscall.c new file +87 -0
87 lines not on this page · raw message
security/landlock/hooks_cred.c new file +47 -0
47 lines not on this page · raw message
security/landlock/hooks_cred.h new file +14 -0
@@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Landlock LSM - credential hooks headers +* +* Copyright © 2019 Mickaël Salaün <[email protected]> +* Copyright © 2019 ANSSI +*/ + +#ifndef _SECURITY_LANDLOCK_HOOKS_CRED_H +#define _SECURITY_LANDLOCK_HOOKS_CRED_H + +__init void landlock_add_hooks_cred (void ); + +#endif /* _SECURITY_LANDLOCK_HOOKS_CRED_H */
security/landlock/init.c new file +30 -0
@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Landlock LSM - initialization +* +* Copyright © 2016-2019 Mickaël Salaün <[email protected]> +* Copyright © 2018-2019 ANSSI +*/ + +#include <linux/lsm_hooks.h> + +#include "common.h" +#include "hooks_cred.h" + +static int __init landlock_init (void ) +{ +pr_info (LANDLOCK_NAME ": Registering hooks\n" ); +landlock_add_hooks_cred (); +return 0 ; +} + +struct lsm_blob_sizes landlock_blob_sizes __lsm_ro_after_init = { + .lbs_cred =sizeof (struct landlock_cred_security ), +}; + +DEFINE_LSM (LANDLOCK_NAME ) = { + .name =LANDLOCK_NAME , + .order =LSM_ORDER_LAST , + .blobs = &landlock_blob_sizes, + .init = landlock_init, +};
security/security.c +15 -0
@@ -264,6 +264,21 @@ static void __init ordered_lsm_parse(const char *order, const char *origin) } } +/* +* In case of 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. We must then load +* potentially-unprivileged security modules after all other LSMs. +* +* LSM_ORDER_LAST is always last and does not appear in the modifiable +* ordered list of enabled LSMs. +*/ +for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) { +if (lsm->order ==LSM_ORDER_LAST ) +append_ordered_lsm (lsm,"last" ); + } +/* Disable all LSMs not in the ordered list. */ for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {if (exists_ordered_lsm (lsm))
Signature · 1 line
2.23.0
Mickaël Salaün
maintainerPATCH v12 4/7 landlock: Add ptrace LSM hooks
In reply to Mickaël SalaünAdd a first Landlock hook that can be used to enforce a security policy or to audit some process activities. For a sandboxing use-case, it is needed to inform the kernel if a task can legitimately debug another. ptrace(2) can also be used by an attacker to impersonate another task and remain undetected while performing malicious activities.
Using ptrace(2) and related features on a target process can lead to a privilege escalation. A sandboxed task must then be able to tell the kernel if another task is more privileged, via ptrace_may_access().
---
Changes since v10:
* revamp and replace the static policy with a Landlock hook which may be used by the corresponding BPF_LANDLOCK_PTRACE program (attach) type and a dedicated process_cmp_landlock_ptrace() BPF helper
* check prog return value against LANDLOCK_RET_DENY (ret is a bitmask)
Changes since v6:
* factor out ptrace check
* constify pointers
* cleanup headers
* use the new security_add_hooks()
--- security/landlock/Makefile | 4 +- security/landlock/bpf_run.c | 62 +++++++++++++++++ security/landlock/bpf_run.h | 25 +++++++ security/landlock/hooks_ptrace.c | 114 +++++++++++++++++++++++++++++++ security/landlock/hooks_ptrace.h | 19 ++++++ security/landlock/init.c | 2 + 6 files changed, 224 insertions(+), 2 deletions(-) create mode 100644 security/landlock/bpf_run.c create mode 100644 security/landlock/bpf_run.h create mode 100644 security/landlock/hooks_ptrace.c create mode 100644 security/landlock/hooks_ptrace.h
security/landlock/Makefile +2 -2
@@ -1,6 +1,6 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o landlock-y := init.o \ - bpf_verify.o bpf_ptrace.o \ + bpf_verify.o bpf_run.o bpf_ptrace.o \ domain_manage.o domain_syscall.o \ - hooks_cred.o + hooks_cred.o hooks_ptrace.o
security/landlock/bpf_run.c new file +62 -0
62 lines not on this page · raw message
security/landlock/bpf_run.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Landlock LSM - eBPF program evaluation headers +* +* Copyright © 2016-2019 Mickaël Salaün <[email protected]> +* Copyright © 2018-2019 ANSSI +*/ + +#ifndef _SECURITY_LANDLOCK_BPF_RUN_H +#define _SECURITY_LANDLOCK_BPF_RUN_H + +#include "common.h" +#include "hooks_ptrace.h" + +struct landlock_hook_ctx { +enum landlock_hook_type type; +union { +struct landlock_hook_ctx_ptrace *ctx_ptrace; + }; +}; + +bool landlock_access_denied (struct landlock_domain *domain, +struct landlock_hook_ctx *hook_ctx); + +#endif /* _SECURITY_LANDLOCK_BPF_RUN_H */
security/landlock/hooks_ptrace.c new file +114 -0
114 lines not on this page · raw message
security/landlock/hooks_ptrace.h new file +19 -0
@@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Landlock LSM - ptrace hooks headers +* +* Copyright © 2017-2019 Mickaël Salaün <[email protected]> +* Copyright © 2019 ANSSI +*/ + +#ifndef _SECURITY_LANDLOCK_HOOKS_PTRACE_H +#define _SECURITY_LANDLOCK_HOOKS_PTRACE_H + +struct landlock_hook_ctx_ptrace ; + +const struct landlock_context_ptrace *landlock_get_ctx_ptrace ( +const struct landlock_hook_ctx_ptrace *hook_ctx); + +__init void landlock_add_hooks_ptrace (void ); + +#endif /* _SECURITY_LANDLOCK_HOOKS_PTRACE_H */
security/landlock/init.c +2 -0
@@ -10,11 +10,13 @@#include "common.h" #include "hooks_cred.h" +#include "hooks_ptrace.h" static int __init landlock_init (void ) {pr_info (LANDLOCK_NAME ": Registering hooks\n" );landlock_add_hooks_cred (); +landlock_add_hooks_ptrace ();return 0 ; }
Signature · 1 line
2.23.0
Mickaël Salaün
maintainerPATCH v12 5/7 bpf,landlock: Add task_landlock_ptrace_ancestor() helper
In reply to Mickaël SalaünThis new task_landlock_ptrace_ancestor() helper can be used to identify if the Landlock domain tied to the current tracer is in the same hierarchy as the domain of tracee.
Indeed, ptrace(2) can be used to impersonate an unsandboxed process and lead to a privilege escalation. A common use-case when sandboxing a process is then to forbid it to debug a less-privileged process. A sandbox process (tracer) should only be allowed to trace another process (tracee) if the tracee has fewer privileges than the tracer. This policy can be implemented with this helper.
More complex helpers could be added in the future to enable other ways to check the relation between the tracer and the tracee.
---
Changes since v10:
* new patch taking inspiration from the previous static ptrace policy
--- include/linux/bpf.h | 2 + include/uapi/linux/bpf.h | 21 ++++++++++- kernel/bpf/verifier.c | 4 ++ security/landlock/bpf_ptrace.c | 68 ++++++++++++++++++++++++++++++++++ security/landlock/bpf_verify.c | 4 ++ 5 files changed, 98 insertions(+), 1 deletion(-)
include/linux/bpf.h +2 -0
@@ -214,6 +214,7 @@ enum bpf_arg_type {ARG_PTR_TO_LONG ,/* pointer to long */ ARG_PTR_TO_SOCKET ,/* pointer to bpf_sock (fullsock) */ ARG_PTR_TO_BTF_ID ,/* pointer to in-kernel struct */ + ARG_PTR_TO_TASK, /* pointer to task_struct */ };/* type of values returned from helper functions */
@@ -1088,6 +1089,7 @@ extern const struct bpf_func_proto bpf_get_local_storage_proto;extern const struct bpf_func_proto bpf_strtol_proto;extern const struct bpf_func_proto bpf_strtoul_proto;extern const struct bpf_func_proto bpf_tcp_sock_proto; +extern const struct bpf_func_proto bpf_task_landlock_ptrace_ancestor_proto;/* Shared helpers among cBPF and eBPF. */ void bpf_user_rnd_init_once (void );
include/uapi/linux/bpf.h +20 -1
@@ -2777,6 +2777,24 @@ union bpf_attr {* restricted to raw_tracepoint bpf programs. * Return * 0 on success, or a negative error in case of failure. +* +* int bpf_task_landlock_ptrace_ancestor(struct task_struct *parent, struct task_struct *child) +* Description +* Check the relation of a potentially parent task with a child +* one, according to their Landlock ptrace hook programs. +* Return +* **-EINVAL** if the child's ptrace programs are not comparable +* to the parent ones, i.e. one of them is an empty set. +* +* **-ENOENT** if the parent's ptrace programs are either in a +* separate hierarchy of the child ones, or if the parent's ptrace +* programs are a superset of the child ones. +* +* 0 if the parent's ptrace programs are the same as the child +* ones. +* +* 1 if the parent's ptrace programs are indeed a subset of the +* child ones. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -2890,7 +2908,8 @@ union bpf_attr {FN (sk_storage_delete), \FN (send_signal), \FN (tcp_gen_syncookie), \ -FN (skb_output), +FN (skb_output), \ +FN (task_landlock_ptrace_ancestor),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
kernel/bpf/verifier.c +4 -0
@@ -3492,6 +3492,10 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 regno, type != PTR_TO_MAP_VALUE && type != expected_type) goto err_type; + }else if (arg_type ==ARG_PTR_TO_TASK ) { + expected_type =PTR_TO_TASK ; +if (type != expected_type) + goto err_type; }else {verbose (env,"unsupported arg_type %d\n" , arg_type);return -EFAULT ;
security/landlock/bpf_ptrace.c +68 -0
80 lines not on this page · raw message
security/landlock/bpf_verify.c +4 -0
@@ -70,6 +70,10 @@ static const struct bpf_func_proto *bpf_landlock_func_proto(return &bpf_map_update_elem_proto;case BPF_FUNC_map_delete_elem:return &bpf_map_delete_elem_proto; +case BPF_FUNC_task_landlock_ptrace_ancestor: +if (get_hook_type (prog) ==LANDLOCK_HOOK_PTRACE ) +return &bpf_task_landlock_ptrace_ancestor_proto; +return NULL ;default :return NULL ; }
Signature · 1 line
2.23.0
Mickaël Salaün
maintainerPATCH v12 6/7 bpf,landlock: Add tests for the Landlock ptrace program type
In reply to Mickaël SalaünTest eBPF program context access and ptrace hooks semantic.
---
Changes since v11:
* cosmetic fixes
Changes since v10:
* rework tests with new Landlock ptrace programs which restrict ptrace thanks to the task_landlock_ptrace_ancestor() helper
* simplify ptrace tests (make expect_ptrace implicit)
* add tests:
* check a child process tracing its parent
* check Landlock domain without ptrace enforcement (e.g. useful for audit/signaling purpose)
* check inherited-only domains
* check task pointer arithmetic
* fix flaky test for multi-core
* increase log size
* cosmetic renames
* update and improve the Makefile
Changes since v9:
* replace subtype with expected_attach_type and expected_attach_triggers
* rename inode_map_lookup() into inode_map_lookup_elem()
* check for inode map entry without value (which is now possible thanks to the pointer null check)
* use read-only inode map for Landlock programs
Changes since v8:
* update eBPF include path for macros
* use TEST_GEN_PROGS and use the generic "clean" target
* add more verbose errors
* update the bpf/verifier files
* remove chain tests (from landlock and bpf/verifier)
* replace the whitelist tests with blacklist tests (because of stateless Landlock programs): remove "dotdot" tests and other depth tests
* sync the landlock Makefile with its bpf sibling directory and use bpf_load_program_xattr()
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
--- scripts/bpf_helpers_doc.py | 1 + tools/include/uapi/linux/bpf.h | 23 +- tools/include/uapi/linux/landlock.h | 22 ++ tools/lib/bpf/libbpf_probes.c | 3 + tools/testing/selftests/bpf/config | 3 + tools/testing/selftests/bpf/test_verifier.c | 1 + .../testing/selftests/bpf/verifier/landlock.c | 56 +++++ tools/testing/selftests/landlock/.gitignore | 5 + tools/testing/selftests/landlock/Makefile | 27 +++ tools/testing/selftests/landlock/config | 5 + tools/testing/selftests/landlock/test.h | 48 ++++ tools/testing/selftests/landlock/test_base.c | 24 ++ .../testing/selftests/landlock/test_ptrace.c | 214 ++++++++++++++++++ 13 files changed, 431 insertions(+), 1 deletion(-) create mode 100644 tools/include/uapi/linux/landlock.h create mode 100644 tools/testing/selftests/bpf/verifier/landlock.c create mode 100644 tools/testing/selftests/landlock/.gitignore create mode 100644 tools/testing/selftests/landlock/Makefile create mode 100644 tools/testing/selftests/landlock/config 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_ptrace.c
scripts/bpf_helpers_doc.py +1 -0
@@ -466,6 +466,7 @@ class PrinterHelpers(Printer): 'const struct sk_buff': 'const struct __sk_buff', 'struct sk_msg_buff': 'struct sk_msg_md', 'struct xdp_buff': 'struct xdp_md', + 'struct task_struct': 'void', } def print_header(self):
tools/include/uapi/linux/bpf.h +22 -1
@@ -173,6 +173,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_CGROUP_SYSCTL ,BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE ,BPF_PROG_TYPE_CGROUP_SOCKOPT , + BPF_PROG_TYPE_LANDLOCK_HOOK, }; enum bpf_attach_type {
@@ -199,6 +200,7 @@ enum bpf_attach_type {BPF_CGROUP_UDP6_RECVMSG ,BPF_CGROUP_GETSOCKOPT ,BPF_CGROUP_SETSOCKOPT , +BPF_LANDLOCK_PTRACE , __MAX_BPF_ATTACH_TYPE };
@@ -2775,6 +2777,24 @@ union bpf_attr {* restricted to raw_tracepoint bpf programs. * Return * 0 on success, or a negative error in case of failure. +* +* int bpf_task_landlock_ptrace_ancestor(struct task_struct *parent, struct task_struct *child) +* Description +* Check the relation of a potentially parent task with a child +* one, according to their Landlock ptrace hook programs. +* Return +* **-EINVAL** if the child's ptrace programs are not comparable +* to the parent ones, i.e. one of them is an empty set. +* +* **-ENOENT** if the parent's ptrace programs are either in a +* separate hierarchy of the child ones, or if the parent's ptrace +* programs are a superset of the child ones. +* +* 0 if the parent's ptrace programs are the same as the child +* ones. +* +* 1 if the parent's ptrace programs are indeed a subset of the +* child ones. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -2888,7 +2908,8 @@ union bpf_attr {FN (sk_storage_delete), \FN (send_signal), \FN (tcp_gen_syncookie), \ -FN (skb_output), +FN (skb_output), \ +FN (task_landlock_ptrace_ancestor),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
tools/include/uapi/linux/landlock.h new file +22 -0
@@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* +* Landlock - UAPI headers +* +* Copyright © 2017-2019 Mickaël Salaün <[email protected]> +* Copyright © 2018-2019 ANSSI +*/ + +#ifndef _UAPI__LINUX_LANDLOCK_H__ +#define _UAPI__LINUX_LANDLOCK_H__ + +#include <linux/types.h> + +#define LANDLOCK_RET_ALLOW 0 +#define LANDLOCK_RET_DENY 1 + +struct landlock_context_ptrace { +__u64 tracer; +__u64 tracee; +}; + +#endif /* _UAPI__LINUX_LANDLOCK_H__ */
tools/lib/bpf/libbpf_probes.c +3 -0
@@ -78,6 +78,9 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,case BPF_PROG_TYPE_KPROBE : xattr.kern_version =get_kernel_version ();break ; +case BPF_PROG_TYPE_LANDLOCK_HOOK : + xattr.expected_attach_type =BPF_LANDLOCK_PTRACE ; +break ;case BPF_PROG_TYPE_UNSPEC :case BPF_PROG_TYPE_SOCKET_FILTER :case BPF_PROG_TYPE_SCHED_CLS :
tools/testing/selftests/bpf/config +3 -0
@@ -35,3 +35,6 @@ CONFIG_MPLS_ROUTING=m CONFIG_MPLS_IPTUNNEL=m CONFIG_IPV6_SIT=m CONFIG_BPF_JIT=y +CONFIG_SECCOMP_FILTER=y +CONFIG_SECURITY=y +CONFIG_SECURITY_LANDLOCK=y
tools/testing/selftests/bpf/test_verifier.c +1 -0
@@ -30,6 +30,7 @@#include <linux/bpf.h> #include <linux/if_ether.h> #include <linux/btf.h> +#include <linux/landlock.h> #include <bpf/bpf.h> #include <bpf/libbpf.h>
tools/testing/selftests/bpf/verifier/landlock.c new file +56 -0
56 lines not on this page · raw message
tools/testing/selftests/landlock/.gitignore new file +5 -0
@@ -0,0 +1,5 @@ +/feature +/fixdep +/*libbpf* +/test_base +/test_ptrace
tools/testing/selftests/landlock/Makefile new file +27 -0
@@ -0,0 +1,27 @@ +# SPDX-License-Identifier: GPL-2.0 + +LIBDIR := $(abspath ../../../lib) +BPFDIR := $(LIBDIR)/bpf +TOOLSDIR := $(abspath ../../../include) +APIDIR := $(TOOLSDIR)/uapi + +CFLAGS += -g -Wall -O2 -I$(APIDIR) -I$(LIBDIR) -I$(TOOLSDIR) +LDLIBS += -lelf + +test_src = $(wildcard test_*.c) + +TEST_GEN_PROGS := $(test_src:.c=) + +include ../lib.mk + +BPFOBJ := $(OUTPUT)/libbpf.a + +$(TEST_GEN_PROGS): $(BPFOBJ) ../kselftest_harness.h + +.PHONY: force + +# force a rebuild of BPFOBJ when its dependencies are updated +force: + +$(BPFOBJ): force + $(MAKE) -C $(BPFDIR) OUTPUT=$(OUTPUT)/
tools/testing/selftests/landlock/config new file +5 -0
@@ -0,0 +1,5 @@ +CONFIG_BPF=y +CONFIG_BPF_SYSCALL=y +CONFIG_SECCOMP_FILTER=y +CONFIG_SECURITY=y +CONFIG_SECURITY_LANDLOCK=y
tools/testing/selftests/landlock/test.h new file +48 -0
48 lines not on this page · raw message
tools/testing/selftests/landlock/test_base.c new file +24 -0
@@ -0,0 +1,24 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Landlock tests - base +* +* Copyright © 2017-2019 Mickaël Salaün <[email protected]> +*/ + +#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_ptrace.c new file +214 -0
214 lines not on this page · raw message
Signature · 1 line
2.23.0
Mickaël Salaün
maintainerPATCH v12 7/7 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 v11:
* cosmetic improvements
Changes since v10:
* replace the filesystem hooks with the ptrace one
* remove the triggers
* update example
* add documenation for Landlock domains and seccomp interaction
* reference more kernel documenation (e.g. LSM hooks)
Changes since v9:
* update with expected attach type and expected attach triggers
Changes since v8:
* remove documentation related to chaining and tagging according to this patch series
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 | 22 ++++ Documentation/security/landlock/kernel.rst | 139 ++++++++++++++++++++ Documentation/security/landlock/user.rst | 142 +++++++++++++++++++++ 4 files changed, 304 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
@@ -15,3 +15,4 @@ Security Documentation self-protection siphash tpm/index + landlock/index
Documentation/security/landlock/index.rst new file +22 -0
@@ -0,0 +1,22 @@ +========================================= +Landlock LSM: programmatic access control +========================================= + +:Author: Mickaël Salaün + +Landlock is a stackable Linux Security Module (LSM) that makes it possible to +create security sandboxes, programmable access-controls or safe endpoint +security agents. 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 processes and hence make a decision according to the +kernel semantic. + +.. toctree:: + + user + kernel
Documentation/security/landlock/kernel.rst new file +139 -0
139 lines not on this page · raw message
Documentation/security/landlock/user.rst new file +142 -0
142 lines not on this page · raw message
Signature · 1 line
2.23.0