From: "Mickaël Salaün" <mic@digikod.net> To: linux-kernel@vger.kernel.org Cc: "Mickaël Salaün" <mic@digikod.net>, "Alexei Starovoitov" <ast@kernel.org>, "Andy Lutomirski" <luto@amacapital.net>, "Arnd Bergmann" <arnd@arndb.de>, "Casey Schaufler" <casey@schaufler-ca.com>, "Daniel Borkmann" <daniel@iogearbox.net>, "Daniel Mack" <daniel@zonque.org>, "David Drysdale" <drysdale@google.com>, "David S . Miller" <davem@davemloft.net>, "Elena Reshetova" <elena.reshetova@intel.com>, "James Morris" <james.l.morris@oracle.com>, "Kees Cook" <keescook@chromium.org>, "Paul Moore" <pmoore@redhat.com>, "Sargun Dhillon" <sargun@sargun.me>, "Serge E . Hallyn" <serge@hallyn.com>, "Will Drewry" <wad@chromium.org>, kernel-hardening@lists.openwall.com, linux-api@vger.kernel.org, linux-security-module@vger.kernel.org, netdev@vger.kernel.org Subject: [RFC v2 08/10] landlock: Handle file system comparisons Date: Thu, 25 Aug 2016 12:32:43 +0200 [thread overview] Message-ID: <1472121165-29071-9-git-send-email-mic@digikod.net> (raw) In-Reply-To: <1472121165-29071-1-git-send-email-mic@digikod.net> Add eBPF functions to compare file system access with a Landlock file system handle: * bpf_landlock_cmp_fs_prop_with_struct_file(prop, map, map_op, file) This function allows to compare the dentry, inode, device or mount point of the currently accessed file, with a reference handle. * bpf_landlock_cmp_fs_beneath_with_struct_file(opt, map, map_op, file) This function allows an eBPF program to check if the current accessed file is the same or in the hierarchy of a reference handle. The goal of file system handle is to abstract kernel objects such as a struct file or a struct inode. Userland can create this kind of handle thanks to the BPF_MAP_UPDATE_ELEM command. The element is a struct landlock_handle containing the handle type (e.g. BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD) and a file descriptor. This could also be any descriptions able to match a struct file or a struct inode (e.g. path or glob string). Signed-off-by: Mickaël Salaün <mic@digikod.net> Cc: Kees Cook <keescook@chromium.org> Cc: Alexei Starovoitov <ast@kernel.org> Cc: James Morris <james.l.morris@oracle.com> Cc: Serge E. Hallyn <serge@hallyn.com> Cc: David S. Miller <davem@davemloft.net> Cc: Daniel Borkmann <daniel@iogearbox.net> --- include/linux/bpf.h | 4 +- include/uapi/linux/bpf.h | 52 +++++++++++- kernel/bpf/arraymap.c | 17 +++- kernel/bpf/verifier.c | 6 ++ security/landlock/Makefile | 2 +- security/landlock/checker_fs.c | 183 +++++++++++++++++++++++++++++++++++++++++ security/landlock/checker_fs.h | 20 +++++ security/landlock/lsm.c | 11 ++- 8 files changed, 288 insertions(+), 7 deletions(-) create mode 100644 security/landlock/checker_fs.c create mode 100644 security/landlock/checker_fs.h diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 557e7efdf0cd..79014aedbea4 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -84,6 +84,7 @@ enum bpf_arg_type { ARG_PTR_TO_STRUCT_FILE, /* pointer to struct file */ ARG_PTR_TO_STRUCT_CRED, /* pointer to struct cred */ + ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS, /* pointer to Landlock FS handle */ }; /* type of values returned from helper functions */ @@ -146,6 +147,7 @@ enum bpf_reg_type { /* Landlock */ PTR_TO_STRUCT_FILE, PTR_TO_STRUCT_CRED, + CONST_PTR_TO_LANDLOCK_HANDLE_FS, }; struct bpf_prog; @@ -207,7 +209,7 @@ struct bpf_array { #ifdef CONFIG_SECURITY_LANDLOCK struct map_landlock_handle { - u32 type; + u32 type; /* e.g. BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD */ union { struct file *file; }; diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 983d14e910ff..88af79dd668c 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -89,10 +89,20 @@ enum bpf_map_type { enum bpf_map_array_type { BPF_MAP_ARRAY_TYPE_UNSPEC, + BPF_MAP_ARRAY_TYPE_LANDLOCK_FS, }; enum bpf_map_handle_type { BPF_MAP_HANDLE_TYPE_UNSPEC, + BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD, + BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_GLOB, +}; + +enum bpf_map_array_op { + BPF_MAP_ARRAY_OP_UNSPEC, + BPF_MAP_ARRAY_OP_OR, + BPF_MAP_ARRAY_OP_AND, + BPF_MAP_ARRAY_OP_XOR, }; enum bpf_prog_type { @@ -325,6 +335,35 @@ enum bpf_func_id { */ BPF_FUNC_skb_get_tunnel_opt, BPF_FUNC_skb_set_tunnel_opt, + + /** + * bpf_landlock_cmp_fs_prop_with_struct_file(prop, map, map_op, file) + * Compare file system handles with a struct file + * + * @prop: properties to check against (e.g. LANDLOCK_FLAG_FS_DENTRY) + * @map: handles to compare against + * @map_op: which elements of the map to use (e.g. BPF_MAP_ARRAY_OP_OR) + * @file: struct file address to compare with (taken from the context) + * + * Return: 0 if the file match the handles, 1 otherwise, or a negative + * value if an error occurred. + */ + BPF_FUNC_landlock_cmp_fs_prop_with_struct_file, + + /** + * bpf_landlock_cmp_fs_beneath_with_struct_file(opt, map, map_op, file) + * Check if a struct file is a leaf of file system handles + * + * @opt: check options (e.g. LANDLOCK_FLAG_OPT_REVERSE) + * @map: handles to compare against + * @map_op: which elements of the map to use (e.g. BPF_MAP_ARRAY_OP_OR) + * @file: struct file address to compare with (taken from the context) + * + * Return: 0 if the file is the same or beneath the handles, + * 1 otherwise, or a negative value if an error occurred. + */ + BPF_FUNC_landlock_cmp_fs_beneath_with_struct_file, + __BPF_FUNC_MAX_ID, }; @@ -398,6 +437,17 @@ struct bpf_tunnel_key { __u32 tunnel_label; }; +/* Handle check flags */ +#define LANDLOCK_FLAG_FS_DENTRY (1 << 0) +#define LANDLOCK_FLAG_FS_INODE (1 << 1) +#define LANDLOCK_FLAG_FS_DEVICE (1 << 2) +#define LANDLOCK_FLAG_FS_MOUNT (1 << 3) +#define _LANDLOCK_FLAG_FS_MASK ((1 << 4) - 1) + +/* Handle option flags */ +#define LANDLOCK_FLAG_OPT_REVERSE (1<<0) +#define _LANDLOCK_FLAG_OPT_MASK ((1 << 1) - 1) + /* Map handle entry */ struct landlock_handle { __u32 type; /* enum bpf_map_handle_type */ @@ -410,7 +460,7 @@ struct landlock_handle { /** * struct landlock_data * - * @hook: LSM hook ID + * @hook: LSM hook ID (e.g. BPF_PROG_TYPE_LANDLOCK_FILE_OPEN) * @cookie: value set by a seccomp-filter return value RET_LANDLOCK. This come * from a trusted seccomp-bpf program: the same process that loaded * this Landlock hook program. diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c index 5938b8ee475b..6804dafd8355 100644 --- a/kernel/bpf/arraymap.c +++ b/kernel/bpf/arraymap.c @@ -508,7 +508,12 @@ static struct bpf_map *landlock_array_map_alloc(union bpf_attr *attr) static void landlock_put_handle(struct map_landlock_handle *handle) { switch (handle->type) { - /* TODO: add handle types */ + case BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD: + if (likely(handle->file)) + fput(handle->file); + else + WARN_ON(1); + break; default: WARN_ON(1); } @@ -533,7 +538,9 @@ static enum bpf_map_array_type landlock_get_array_type( enum bpf_map_handle_type handle_type) { switch (handle_type) { - /* TODO: add handle types */ + case BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD: + case BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_GLOB: + return BPF_MAP_ARRAY_TYPE_LANDLOCK_FS; case BPF_MAP_HANDLE_TYPE_UNSPEC: default: return -EINVAL; @@ -550,6 +557,7 @@ static inline long landlock_store_handle(struct map_landlock_handle *dst, struct landlock_handle *khandle) { struct path kpath; + struct file *handle_file; if (unlikely(!khandle)) return -EINVAL; @@ -557,7 +565,10 @@ static inline long landlock_store_handle(struct map_landlock_handle *dst, /* access control already done for the FD */ switch (khandle->type) { - /* TODO: add handle types */ + case BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD: + FGET_OR_RET(handle_file, khandle->fd); + dst->file = handle_file; + break; default: WARN_ON(1); path_put(&kpath); diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 2931e2efcc10..b182c88d5c13 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -246,6 +246,7 @@ static const char * const reg_type_str[] = { [PTR_TO_PACKET_END] = "pkt_end", [PTR_TO_STRUCT_FILE] = "struct_file", [PTR_TO_STRUCT_CRED] = "struct_cred", + [CONST_PTR_TO_LANDLOCK_HANDLE_FS] = "landlock_handle_fs", }; static void print_verifier_state(struct verifier_state *state) @@ -558,6 +559,7 @@ static bool is_spillable_regtype(enum bpf_reg_type type) case CONST_PTR_TO_MAP: case PTR_TO_STRUCT_FILE: case PTR_TO_STRUCT_CRED: + case CONST_PTR_TO_LANDLOCK_HANDLE_FS: return true; default: return false; @@ -951,6 +953,8 @@ static int check_func_arg(struct verifier_env *env, u32 regno, expected_type = PTR_TO_STRUCT_FILE; } else if (arg_type == ARG_PTR_TO_STRUCT_CRED) { expected_type = PTR_TO_STRUCT_CRED; + } else if (arg_type == ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS) { + expected_type = CONST_PTR_TO_LANDLOCK_HANDLE_FS; } else if (arg_type == ARG_PTR_TO_STACK || arg_type == ARG_PTR_TO_RAW_STACK) { expected_type = PTR_TO_STACK; @@ -1727,6 +1731,8 @@ static struct bpf_map *ld_imm64_to_map_ptr(struct bpf_insn *insn) static inline enum bpf_reg_type bpf_reg_type_from_map(struct bpf_map *map) { switch (map->map_array_type) { + case BPF_MAP_ARRAY_TYPE_LANDLOCK_FS: + return CONST_PTR_TO_LANDLOCK_HANDLE_FS; case BPF_MAP_ARRAY_TYPE_UNSPEC: default: return CONST_PTR_TO_MAP; diff --git a/security/landlock/Makefile b/security/landlock/Makefile index 59669d70bc7e..27f359a8cfaa 100644 --- a/security/landlock/Makefile +++ b/security/landlock/Makefile @@ -1,3 +1,3 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o -landlock-y := lsm.o +landlock-y := lsm.o checker_fs.o diff --git a/security/landlock/checker_fs.c b/security/landlock/checker_fs.c new file mode 100644 index 000000000000..4d2f1e5d41b6 --- /dev/null +++ b/security/landlock/checker_fs.c @@ -0,0 +1,183 @@ +/* + * Landlock LSM - File System Checkers + * + * Copyright (C) 2016 Mickaël Salaün <mic@digikod.net> + * + * 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/bpf.h> /* enum bpf_map_array_op */ +#include <linux/errno.h> +#include <linux/fs.h> /* path_is_under() */ +#include <linux/path.h> /* struct path */ + +#include "checker_fs.h" + +#define EQUAL_NOT_NULL(a, b) (a && a == b) + +/* + * bpf_landlock_cmp_fs_prop_with_struct_file + * + * Cf. include/uapi/linux/bpf.h + */ +static inline u64 bpf_landlock_cmp_fs_prop_with_struct_file(u64 r1_property, + u64 r2_map, u64 r3_map_op, u64 r4_file, u64 r5) +{ + u8 property = (u8) r1_property; + struct bpf_map *map = (struct bpf_map *) (unsigned long) r2_map; + enum bpf_map_array_op map_op = r3_map_op; + struct file *file = (struct file *) (unsigned long) r4_file; + struct bpf_array *array = container_of(map, struct bpf_array, map); + struct path *p1, *p2; + struct map_landlock_handle *handle; + int i; + bool result_dentry = !(property & LANDLOCK_FLAG_FS_DENTRY); + bool result_inode = !(property & LANDLOCK_FLAG_FS_INODE); + bool result_device = !(property & LANDLOCK_FLAG_FS_DEVICE); + bool result_mount = !(property & LANDLOCK_FLAG_FS_MOUNT); + + /* ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS is a arraymap */ + if (unlikely(!map)) { + WARN_ON(1); + return -EFAULT; + } + if (unlikely(!file)) + return -ENOENT; + if (unlikely((property | _LANDLOCK_FLAG_FS_MASK) != _LANDLOCK_FLAG_FS_MASK)) + return -EINVAL; + + /* for now, only handle OP_OR */ + switch (map_op) { + case BPF_MAP_ARRAY_OP_OR: + break; + case BPF_MAP_ARRAY_OP_UNSPEC: + case BPF_MAP_ARRAY_OP_AND: + case BPF_MAP_ARRAY_OP_XOR: + default: + return -EINVAL; + } + + synchronize_rcu(); + + for (i = 0; i < array->n_entries; i++) { + handle = (struct map_landlock_handle *) + (array->value + array->elem_size * i); + + if (handle->type != BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD) { + WARN_ON(1); + return -EFAULT; + } + + p1 = &handle->file->f_path; + p2 = &file->f_path; + if (unlikely(!p1 || !p2)) { + WARN_ON(1); + return -EFAULT; + } + + if (!result_dentry && p1->dentry == p2->dentry) + result_dentry = true; + /* TODO: use d_inode_rcu() instead? */ + if (!result_inode + && EQUAL_NOT_NULL(d_inode(p1->dentry)->i_ino, + d_inode(p2->dentry)->i_ino)) + result_inode = true; + /* check superblock instead of device major/minor */ + if (!result_device + && EQUAL_NOT_NULL(d_inode(p1->dentry)->i_sb, + d_inode(p2->dentry)->i_sb)) + result_device = true; + if (!result_mount && EQUAL_NOT_NULL(p1->mnt, p2->mnt)) + result_mount = true; + if (result_dentry && result_inode && result_device && result_mount) + return 0; + } + return 1; +} + +const struct bpf_func_proto bpf_landlock_cmp_fs_prop_with_struct_file_proto = { + .func = bpf_landlock_cmp_fs_prop_with_struct_file, + .gpl_only = true, + .ret_type = RET_INTEGER, + .arg1_type = ARG_ANYTHING, + .arg2_type = ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS, + .arg3_type = ARG_ANYTHING, + .arg4_type = ARG_PTR_TO_STRUCT_FILE, +}; + +/* + * bpf_landlock_cmp_fs_beneath_with_struct_file + * + * Cf. include/uapi/linux/bpf.h + */ +static inline u64 bpf_landlock_cmp_fs_beneath_with_struct_file(u64 r1_option, + u64 r2_map, u64 r3_map_op, u64 r4_file, u64 r5) +{ + u8 option = (u8) r1_option; + struct bpf_map *map = (struct bpf_map *) (unsigned long) r2_map; + enum bpf_map_array_op map_op = r3_map_op; + struct file *file = (struct file *) (unsigned long) r4_file; + struct bpf_array *array = container_of(map, struct bpf_array, map); + struct path *p1, *p2; + struct map_landlock_handle *handle; + int i; + + /* ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS is an arraymap */ + if (unlikely(!map)) { + WARN_ON(1); + return -EFAULT; + } + /* @file can be null for anonymous mmap */ + if (unlikely(!file)) + return -ENOENT; + if (unlikely((option | _LANDLOCK_FLAG_OPT_MASK) != _LANDLOCK_FLAG_OPT_MASK)) + return -EINVAL; + + /* for now, only handle OP_OR */ + switch (map_op) { + case BPF_MAP_ARRAY_OP_OR: + break; + case BPF_MAP_ARRAY_OP_UNSPEC: + case BPF_MAP_ARRAY_OP_AND: + case BPF_MAP_ARRAY_OP_XOR: + default: + return -EINVAL; + } + + synchronize_rcu(); + + for (i = 0; i < array->n_entries; i++) { + handle = (struct map_landlock_handle *) + (array->value + array->elem_size * i); + + /* protected by the proto types, should not happen */ + if (unlikely(handle->type != BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD)) { + WARN_ON(1); + return -EINVAL; + } + + if (option & LANDLOCK_FLAG_OPT_REVERSE) { + p1 = &file->f_path; + p2 = &handle->file->f_path; + } else { + p1 = &handle->file->f_path; + p2 = &file->f_path; + } + + if (path_is_under(p2, p1)) + return 0; + } + return 1; +} + +const struct bpf_func_proto bpf_landlock_cmp_fs_beneath_with_struct_file_proto = { + .func = bpf_landlock_cmp_fs_beneath_with_struct_file, + .gpl_only = true, + .ret_type = RET_INTEGER, + .arg1_type = ARG_ANYTHING, + .arg2_type = ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS, + .arg3_type = ARG_ANYTHING, + .arg4_type = ARG_PTR_TO_STRUCT_FILE, +}; diff --git a/security/landlock/checker_fs.h b/security/landlock/checker_fs.h new file mode 100644 index 000000000000..a62f84e39efd --- /dev/null +++ b/security/landlock/checker_fs.h @@ -0,0 +1,20 @@ +/* + * Landlock LSM - File System Checkers + * + * Copyright (C) 2016 Mickaël Salaün <mic@digikod.net> + * + * 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_CHECKER_FS_H +#define _SECURITY_LANDLOCK_CHECKER_FS_H + +#include <linux/fs.h> +#include <linux/seccomp.h> + +extern const struct bpf_func_proto bpf_landlock_cmp_fs_prop_with_struct_file_proto; +extern const struct bpf_func_proto bpf_landlock_cmp_fs_beneath_with_struct_file_proto; + +#endif /* _SECURITY_LANDLOCK_CHECKER_FS_H */ diff --git a/security/landlock/lsm.c b/security/landlock/lsm.c index 322309068066..8645743243b6 100644 --- a/security/landlock/lsm.c +++ b/security/landlock/lsm.c @@ -16,6 +16,8 @@ #include <linux/lsm_hooks.h> #include <linux/seccomp.h> /* struct seccomp_* */ +#include "checker_fs.h" + #define LANDLOCK_HOOK_INIT(NAME) LSM_HOOK_INIT(NAME, landlock_hook_##NAME) #define LANDLOCK_HOOKx(X, NAME, CNAME, ...) \ @@ -117,7 +119,14 @@ static int landlock_run_prog(__u64 args[6]) static const struct bpf_func_proto *bpf_landlock_func_proto( enum bpf_func_id func_id) { - return NULL; + switch (func_id) { + case BPF_FUNC_landlock_cmp_fs_prop_with_struct_file: + return &bpf_landlock_cmp_fs_prop_with_struct_file_proto; + case BPF_FUNC_landlock_cmp_fs_beneath_with_struct_file: + return &bpf_landlock_cmp_fs_beneath_with_struct_file_proto; + default: + return NULL; + } } static u32 landlock_convert_ctx_access(enum bpf_access_type type, int dst_reg, -- 2.8.1
WARNING: multiple messages have this Message-ID (diff)
From: "Mickaël Salaün" <mic@digikod.net> To: linux-kernel@vger.kernel.org Cc: "Mickaël Salaün" <mic@digikod.net>, "Alexei Starovoitov" <ast@kernel.org>, "Andy Lutomirski" <luto@amacapital.net>, "Arnd Bergmann" <arnd@arndb.de>, "Casey Schaufler" <casey@schaufler-ca.com>, "Daniel Borkmann" <daniel@iogearbox.net>, "Daniel Mack" <daniel@zonque.org>, "David Drysdale" <drysdale@google.com>, "David S . Miller" <davem@davemloft.net>, "Elena Reshetova" <elena.reshetova@intel.com>, "James Morris" <james.l.morris@oracle.com>, "Kees Cook" <keescook@chromium.org>, "Paul Moore" <pmoore@redhat.com>, "Sargun Dhillon" <sargun@sargun.me>, "Serge E . Hallyn" <serge@hallyn.com>, "Will Drewry" <wad@chromium.org>, kernel-hardening@lists.openwall.com, linux-api@vger.kernel.org, linux-security-module@vger.kernel.org, netdev@vger.kernel.org Subject: [kernel-hardening] [RFC v2 08/10] landlock: Handle file system comparisons Date: Thu, 25 Aug 2016 12:32:43 +0200 [thread overview] Message-ID: <1472121165-29071-9-git-send-email-mic@digikod.net> (raw) In-Reply-To: <1472121165-29071-1-git-send-email-mic@digikod.net> Add eBPF functions to compare file system access with a Landlock file system handle: * bpf_landlock_cmp_fs_prop_with_struct_file(prop, map, map_op, file) This function allows to compare the dentry, inode, device or mount point of the currently accessed file, with a reference handle. * bpf_landlock_cmp_fs_beneath_with_struct_file(opt, map, map_op, file) This function allows an eBPF program to check if the current accessed file is the same or in the hierarchy of a reference handle. The goal of file system handle is to abstract kernel objects such as a struct file or a struct inode. Userland can create this kind of handle thanks to the BPF_MAP_UPDATE_ELEM command. The element is a struct landlock_handle containing the handle type (e.g. BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD) and a file descriptor. This could also be any descriptions able to match a struct file or a struct inode (e.g. path or glob string). Signed-off-by: Mickaël Salaün <mic@digikod.net> Cc: Kees Cook <keescook@chromium.org> Cc: Alexei Starovoitov <ast@kernel.org> Cc: James Morris <james.l.morris@oracle.com> Cc: Serge E. Hallyn <serge@hallyn.com> Cc: David S. Miller <davem@davemloft.net> Cc: Daniel Borkmann <daniel@iogearbox.net> --- include/linux/bpf.h | 4 +- include/uapi/linux/bpf.h | 52 +++++++++++- kernel/bpf/arraymap.c | 17 +++- kernel/bpf/verifier.c | 6 ++ security/landlock/Makefile | 2 +- security/landlock/checker_fs.c | 183 +++++++++++++++++++++++++++++++++++++++++ security/landlock/checker_fs.h | 20 +++++ security/landlock/lsm.c | 11 ++- 8 files changed, 288 insertions(+), 7 deletions(-) create mode 100644 security/landlock/checker_fs.c create mode 100644 security/landlock/checker_fs.h diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 557e7efdf0cd..79014aedbea4 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -84,6 +84,7 @@ enum bpf_arg_type { ARG_PTR_TO_STRUCT_FILE, /* pointer to struct file */ ARG_PTR_TO_STRUCT_CRED, /* pointer to struct cred */ + ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS, /* pointer to Landlock FS handle */ }; /* type of values returned from helper functions */ @@ -146,6 +147,7 @@ enum bpf_reg_type { /* Landlock */ PTR_TO_STRUCT_FILE, PTR_TO_STRUCT_CRED, + CONST_PTR_TO_LANDLOCK_HANDLE_FS, }; struct bpf_prog; @@ -207,7 +209,7 @@ struct bpf_array { #ifdef CONFIG_SECURITY_LANDLOCK struct map_landlock_handle { - u32 type; + u32 type; /* e.g. BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD */ union { struct file *file; }; diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 983d14e910ff..88af79dd668c 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -89,10 +89,20 @@ enum bpf_map_type { enum bpf_map_array_type { BPF_MAP_ARRAY_TYPE_UNSPEC, + BPF_MAP_ARRAY_TYPE_LANDLOCK_FS, }; enum bpf_map_handle_type { BPF_MAP_HANDLE_TYPE_UNSPEC, + BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD, + BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_GLOB, +}; + +enum bpf_map_array_op { + BPF_MAP_ARRAY_OP_UNSPEC, + BPF_MAP_ARRAY_OP_OR, + BPF_MAP_ARRAY_OP_AND, + BPF_MAP_ARRAY_OP_XOR, }; enum bpf_prog_type { @@ -325,6 +335,35 @@ enum bpf_func_id { */ BPF_FUNC_skb_get_tunnel_opt, BPF_FUNC_skb_set_tunnel_opt, + + /** + * bpf_landlock_cmp_fs_prop_with_struct_file(prop, map, map_op, file) + * Compare file system handles with a struct file + * + * @prop: properties to check against (e.g. LANDLOCK_FLAG_FS_DENTRY) + * @map: handles to compare against + * @map_op: which elements of the map to use (e.g. BPF_MAP_ARRAY_OP_OR) + * @file: struct file address to compare with (taken from the context) + * + * Return: 0 if the file match the handles, 1 otherwise, or a negative + * value if an error occurred. + */ + BPF_FUNC_landlock_cmp_fs_prop_with_struct_file, + + /** + * bpf_landlock_cmp_fs_beneath_with_struct_file(opt, map, map_op, file) + * Check if a struct file is a leaf of file system handles + * + * @opt: check options (e.g. LANDLOCK_FLAG_OPT_REVERSE) + * @map: handles to compare against + * @map_op: which elements of the map to use (e.g. BPF_MAP_ARRAY_OP_OR) + * @file: struct file address to compare with (taken from the context) + * + * Return: 0 if the file is the same or beneath the handles, + * 1 otherwise, or a negative value if an error occurred. + */ + BPF_FUNC_landlock_cmp_fs_beneath_with_struct_file, + __BPF_FUNC_MAX_ID, }; @@ -398,6 +437,17 @@ struct bpf_tunnel_key { __u32 tunnel_label; }; +/* Handle check flags */ +#define LANDLOCK_FLAG_FS_DENTRY (1 << 0) +#define LANDLOCK_FLAG_FS_INODE (1 << 1) +#define LANDLOCK_FLAG_FS_DEVICE (1 << 2) +#define LANDLOCK_FLAG_FS_MOUNT (1 << 3) +#define _LANDLOCK_FLAG_FS_MASK ((1 << 4) - 1) + +/* Handle option flags */ +#define LANDLOCK_FLAG_OPT_REVERSE (1<<0) +#define _LANDLOCK_FLAG_OPT_MASK ((1 << 1) - 1) + /* Map handle entry */ struct landlock_handle { __u32 type; /* enum bpf_map_handle_type */ @@ -410,7 +460,7 @@ struct landlock_handle { /** * struct landlock_data * - * @hook: LSM hook ID + * @hook: LSM hook ID (e.g. BPF_PROG_TYPE_LANDLOCK_FILE_OPEN) * @cookie: value set by a seccomp-filter return value RET_LANDLOCK. This come * from a trusted seccomp-bpf program: the same process that loaded * this Landlock hook program. diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c index 5938b8ee475b..6804dafd8355 100644 --- a/kernel/bpf/arraymap.c +++ b/kernel/bpf/arraymap.c @@ -508,7 +508,12 @@ static struct bpf_map *landlock_array_map_alloc(union bpf_attr *attr) static void landlock_put_handle(struct map_landlock_handle *handle) { switch (handle->type) { - /* TODO: add handle types */ + case BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD: + if (likely(handle->file)) + fput(handle->file); + else + WARN_ON(1); + break; default: WARN_ON(1); } @@ -533,7 +538,9 @@ static enum bpf_map_array_type landlock_get_array_type( enum bpf_map_handle_type handle_type) { switch (handle_type) { - /* TODO: add handle types */ + case BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD: + case BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_GLOB: + return BPF_MAP_ARRAY_TYPE_LANDLOCK_FS; case BPF_MAP_HANDLE_TYPE_UNSPEC: default: return -EINVAL; @@ -550,6 +557,7 @@ static inline long landlock_store_handle(struct map_landlock_handle *dst, struct landlock_handle *khandle) { struct path kpath; + struct file *handle_file; if (unlikely(!khandle)) return -EINVAL; @@ -557,7 +565,10 @@ static inline long landlock_store_handle(struct map_landlock_handle *dst, /* access control already done for the FD */ switch (khandle->type) { - /* TODO: add handle types */ + case BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD: + FGET_OR_RET(handle_file, khandle->fd); + dst->file = handle_file; + break; default: WARN_ON(1); path_put(&kpath); diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 2931e2efcc10..b182c88d5c13 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -246,6 +246,7 @@ static const char * const reg_type_str[] = { [PTR_TO_PACKET_END] = "pkt_end", [PTR_TO_STRUCT_FILE] = "struct_file", [PTR_TO_STRUCT_CRED] = "struct_cred", + [CONST_PTR_TO_LANDLOCK_HANDLE_FS] = "landlock_handle_fs", }; static void print_verifier_state(struct verifier_state *state) @@ -558,6 +559,7 @@ static bool is_spillable_regtype(enum bpf_reg_type type) case CONST_PTR_TO_MAP: case PTR_TO_STRUCT_FILE: case PTR_TO_STRUCT_CRED: + case CONST_PTR_TO_LANDLOCK_HANDLE_FS: return true; default: return false; @@ -951,6 +953,8 @@ static int check_func_arg(struct verifier_env *env, u32 regno, expected_type = PTR_TO_STRUCT_FILE; } else if (arg_type == ARG_PTR_TO_STRUCT_CRED) { expected_type = PTR_TO_STRUCT_CRED; + } else if (arg_type == ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS) { + expected_type = CONST_PTR_TO_LANDLOCK_HANDLE_FS; } else if (arg_type == ARG_PTR_TO_STACK || arg_type == ARG_PTR_TO_RAW_STACK) { expected_type = PTR_TO_STACK; @@ -1727,6 +1731,8 @@ static struct bpf_map *ld_imm64_to_map_ptr(struct bpf_insn *insn) static inline enum bpf_reg_type bpf_reg_type_from_map(struct bpf_map *map) { switch (map->map_array_type) { + case BPF_MAP_ARRAY_TYPE_LANDLOCK_FS: + return CONST_PTR_TO_LANDLOCK_HANDLE_FS; case BPF_MAP_ARRAY_TYPE_UNSPEC: default: return CONST_PTR_TO_MAP; diff --git a/security/landlock/Makefile b/security/landlock/Makefile index 59669d70bc7e..27f359a8cfaa 100644 --- a/security/landlock/Makefile +++ b/security/landlock/Makefile @@ -1,3 +1,3 @@ obj-$(CONFIG_SECURITY_LANDLOCK) := landlock.o -landlock-y := lsm.o +landlock-y := lsm.o checker_fs.o diff --git a/security/landlock/checker_fs.c b/security/landlock/checker_fs.c new file mode 100644 index 000000000000..4d2f1e5d41b6 --- /dev/null +++ b/security/landlock/checker_fs.c @@ -0,0 +1,183 @@ +/* + * Landlock LSM - File System Checkers + * + * Copyright (C) 2016 Mickaël Salaün <mic@digikod.net> + * + * 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/bpf.h> /* enum bpf_map_array_op */ +#include <linux/errno.h> +#include <linux/fs.h> /* path_is_under() */ +#include <linux/path.h> /* struct path */ + +#include "checker_fs.h" + +#define EQUAL_NOT_NULL(a, b) (a && a == b) + +/* + * bpf_landlock_cmp_fs_prop_with_struct_file + * + * Cf. include/uapi/linux/bpf.h + */ +static inline u64 bpf_landlock_cmp_fs_prop_with_struct_file(u64 r1_property, + u64 r2_map, u64 r3_map_op, u64 r4_file, u64 r5) +{ + u8 property = (u8) r1_property; + struct bpf_map *map = (struct bpf_map *) (unsigned long) r2_map; + enum bpf_map_array_op map_op = r3_map_op; + struct file *file = (struct file *) (unsigned long) r4_file; + struct bpf_array *array = container_of(map, struct bpf_array, map); + struct path *p1, *p2; + struct map_landlock_handle *handle; + int i; + bool result_dentry = !(property & LANDLOCK_FLAG_FS_DENTRY); + bool result_inode = !(property & LANDLOCK_FLAG_FS_INODE); + bool result_device = !(property & LANDLOCK_FLAG_FS_DEVICE); + bool result_mount = !(property & LANDLOCK_FLAG_FS_MOUNT); + + /* ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS is a arraymap */ + if (unlikely(!map)) { + WARN_ON(1); + return -EFAULT; + } + if (unlikely(!file)) + return -ENOENT; + if (unlikely((property | _LANDLOCK_FLAG_FS_MASK) != _LANDLOCK_FLAG_FS_MASK)) + return -EINVAL; + + /* for now, only handle OP_OR */ + switch (map_op) { + case BPF_MAP_ARRAY_OP_OR: + break; + case BPF_MAP_ARRAY_OP_UNSPEC: + case BPF_MAP_ARRAY_OP_AND: + case BPF_MAP_ARRAY_OP_XOR: + default: + return -EINVAL; + } + + synchronize_rcu(); + + for (i = 0; i < array->n_entries; i++) { + handle = (struct map_landlock_handle *) + (array->value + array->elem_size * i); + + if (handle->type != BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD) { + WARN_ON(1); + return -EFAULT; + } + + p1 = &handle->file->f_path; + p2 = &file->f_path; + if (unlikely(!p1 || !p2)) { + WARN_ON(1); + return -EFAULT; + } + + if (!result_dentry && p1->dentry == p2->dentry) + result_dentry = true; + /* TODO: use d_inode_rcu() instead? */ + if (!result_inode + && EQUAL_NOT_NULL(d_inode(p1->dentry)->i_ino, + d_inode(p2->dentry)->i_ino)) + result_inode = true; + /* check superblock instead of device major/minor */ + if (!result_device + && EQUAL_NOT_NULL(d_inode(p1->dentry)->i_sb, + d_inode(p2->dentry)->i_sb)) + result_device = true; + if (!result_mount && EQUAL_NOT_NULL(p1->mnt, p2->mnt)) + result_mount = true; + if (result_dentry && result_inode && result_device && result_mount) + return 0; + } + return 1; +} + +const struct bpf_func_proto bpf_landlock_cmp_fs_prop_with_struct_file_proto = { + .func = bpf_landlock_cmp_fs_prop_with_struct_file, + .gpl_only = true, + .ret_type = RET_INTEGER, + .arg1_type = ARG_ANYTHING, + .arg2_type = ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS, + .arg3_type = ARG_ANYTHING, + .arg4_type = ARG_PTR_TO_STRUCT_FILE, +}; + +/* + * bpf_landlock_cmp_fs_beneath_with_struct_file + * + * Cf. include/uapi/linux/bpf.h + */ +static inline u64 bpf_landlock_cmp_fs_beneath_with_struct_file(u64 r1_option, + u64 r2_map, u64 r3_map_op, u64 r4_file, u64 r5) +{ + u8 option = (u8) r1_option; + struct bpf_map *map = (struct bpf_map *) (unsigned long) r2_map; + enum bpf_map_array_op map_op = r3_map_op; + struct file *file = (struct file *) (unsigned long) r4_file; + struct bpf_array *array = container_of(map, struct bpf_array, map); + struct path *p1, *p2; + struct map_landlock_handle *handle; + int i; + + /* ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS is an arraymap */ + if (unlikely(!map)) { + WARN_ON(1); + return -EFAULT; + } + /* @file can be null for anonymous mmap */ + if (unlikely(!file)) + return -ENOENT; + if (unlikely((option | _LANDLOCK_FLAG_OPT_MASK) != _LANDLOCK_FLAG_OPT_MASK)) + return -EINVAL; + + /* for now, only handle OP_OR */ + switch (map_op) { + case BPF_MAP_ARRAY_OP_OR: + break; + case BPF_MAP_ARRAY_OP_UNSPEC: + case BPF_MAP_ARRAY_OP_AND: + case BPF_MAP_ARRAY_OP_XOR: + default: + return -EINVAL; + } + + synchronize_rcu(); + + for (i = 0; i < array->n_entries; i++) { + handle = (struct map_landlock_handle *) + (array->value + array->elem_size * i); + + /* protected by the proto types, should not happen */ + if (unlikely(handle->type != BPF_MAP_HANDLE_TYPE_LANDLOCK_FS_FD)) { + WARN_ON(1); + return -EINVAL; + } + + if (option & LANDLOCK_FLAG_OPT_REVERSE) { + p1 = &file->f_path; + p2 = &handle->file->f_path; + } else { + p1 = &handle->file->f_path; + p2 = &file->f_path; + } + + if (path_is_under(p2, p1)) + return 0; + } + return 1; +} + +const struct bpf_func_proto bpf_landlock_cmp_fs_beneath_with_struct_file_proto = { + .func = bpf_landlock_cmp_fs_beneath_with_struct_file, + .gpl_only = true, + .ret_type = RET_INTEGER, + .arg1_type = ARG_ANYTHING, + .arg2_type = ARG_CONST_PTR_TO_LANDLOCK_HANDLE_FS, + .arg3_type = ARG_ANYTHING, + .arg4_type = ARG_PTR_TO_STRUCT_FILE, +}; diff --git a/security/landlock/checker_fs.h b/security/landlock/checker_fs.h new file mode 100644 index 000000000000..a62f84e39efd --- /dev/null +++ b/security/landlock/checker_fs.h @@ -0,0 +1,20 @@ +/* + * Landlock LSM - File System Checkers + * + * Copyright (C) 2016 Mickaël Salaün <mic@digikod.net> + * + * 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_CHECKER_FS_H +#define _SECURITY_LANDLOCK_CHECKER_FS_H + +#include <linux/fs.h> +#include <linux/seccomp.h> + +extern const struct bpf_func_proto bpf_landlock_cmp_fs_prop_with_struct_file_proto; +extern const struct bpf_func_proto bpf_landlock_cmp_fs_beneath_with_struct_file_proto; + +#endif /* _SECURITY_LANDLOCK_CHECKER_FS_H */ diff --git a/security/landlock/lsm.c b/security/landlock/lsm.c index 322309068066..8645743243b6 100644 --- a/security/landlock/lsm.c +++ b/security/landlock/lsm.c @@ -16,6 +16,8 @@ #include <linux/lsm_hooks.h> #include <linux/seccomp.h> /* struct seccomp_* */ +#include "checker_fs.h" + #define LANDLOCK_HOOK_INIT(NAME) LSM_HOOK_INIT(NAME, landlock_hook_##NAME) #define LANDLOCK_HOOKx(X, NAME, CNAME, ...) \ @@ -117,7 +119,14 @@ static int landlock_run_prog(__u64 args[6]) static const struct bpf_func_proto *bpf_landlock_func_proto( enum bpf_func_id func_id) { - return NULL; + switch (func_id) { + case BPF_FUNC_landlock_cmp_fs_prop_with_struct_file: + return &bpf_landlock_cmp_fs_prop_with_struct_file_proto; + case BPF_FUNC_landlock_cmp_fs_beneath_with_struct_file: + return &bpf_landlock_cmp_fs_beneath_with_struct_file_proto; + default: + return NULL; + } } static u32 landlock_convert_ctx_access(enum bpf_access_type type, int dst_reg, -- 2.8.1
next prev parent reply other threads:[~2016-08-25 10:47 UTC|newest] Thread overview: 180+ messages / expand[flat|nested] mbox.gz Atom feed top 2016-08-25 10:32 [RFC v2 00/10] Landlock LSM: Unprivileged sandboxing Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 01/10] landlock: Add Kconfig Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 02/10] bpf: Move u64_to_ptr() to BPF headers and inline it Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 03/10] bpf,landlock: Add a new arraymap type to deal with (Landlock) handles Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 04/10] seccomp: Split put_seccomp_filter() with put_seccomp() Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 05/10] seccomp: Handle Landlock Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 10:32 ` Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 06/10] landlock: Add LSM hooks Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-30 18:56 ` Andy Lutomirski 2016-08-30 18:56 ` [kernel-hardening] " Andy Lutomirski 2016-08-30 18:56 ` Andy Lutomirski 2016-08-30 18:56 ` Andy Lutomirski 2016-08-30 20:10 ` Mickaël Salaün 2016-08-30 20:10 ` [kernel-hardening] " Mickaël Salaün 2016-08-30 20:10 ` Mickaël Salaün 2016-08-30 20:10 ` Mickaël Salaün 2016-08-30 20:18 ` Andy Lutomirski 2016-08-30 20:18 ` [kernel-hardening] " Andy Lutomirski 2016-08-30 20:18 ` Andy Lutomirski 2016-08-30 20:18 ` Andy Lutomirski 2016-08-30 20:27 ` Mickaël Salaün 2016-08-30 20:27 ` [kernel-hardening] " Mickaël Salaün 2016-08-30 20:27 ` Mickaël Salaün 2016-08-30 20:27 ` Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 07/10] landlock: Add errno check Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 11:13 ` Andy Lutomirski 2016-08-25 11:13 ` [kernel-hardening] " Andy Lutomirski 2016-08-25 11:13 ` Andy Lutomirski 2016-08-25 10:32 ` Mickaël Salaün [this message] 2016-08-25 10:32 ` [kernel-hardening] [RFC v2 08/10] landlock: Handle file system comparisons Mickaël Salaün 2016-08-25 11:12 ` Andy Lutomirski 2016-08-25 11:12 ` [kernel-hardening] " Andy Lutomirski 2016-08-25 11:12 ` Andy Lutomirski 2016-08-25 14:10 ` Mickaël Salaün 2016-08-25 14:10 ` [kernel-hardening] " Mickaël Salaün 2016-08-26 14:57 ` Andy Lutomirski 2016-08-26 14:57 ` [kernel-hardening] " Andy Lutomirski 2016-08-27 13:45 ` Mickaël Salaün 2016-08-27 13:45 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 13:45 ` Mickaël Salaün 2016-08-27 13:45 ` Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 09/10] landlock: Handle cgroups Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 11:09 ` Andy Lutomirski 2016-08-25 11:09 ` [kernel-hardening] " Andy Lutomirski 2016-08-25 11:09 ` Andy Lutomirski 2016-08-25 14:44 ` Mickaël Salaün 2016-08-25 14:44 ` [kernel-hardening] " Mickaël Salaün 2016-08-26 12:55 ` Tejun Heo 2016-08-26 12:55 ` [kernel-hardening] " Tejun Heo 2016-08-26 12:55 ` Tejun Heo 2016-08-26 12:55 ` Tejun Heo 2016-08-26 14:20 ` Andy Lutomirski 2016-08-26 14:20 ` [kernel-hardening] " Andy Lutomirski 2016-08-26 15:50 ` Tejun Heo 2016-08-26 15:50 ` [kernel-hardening] " Tejun Heo 2016-08-26 2:14 ` Alexei Starovoitov 2016-08-26 2:14 ` [kernel-hardening] " Alexei Starovoitov 2016-08-26 15:10 ` Mickaël Salaün 2016-08-26 15:10 ` [kernel-hardening] " Mickaël Salaün 2016-08-26 15:10 ` Mickaël Salaün 2016-08-26 15:10 ` Mickaël Salaün 2016-08-26 23:05 ` Alexei Starovoitov 2016-08-26 23:05 ` [kernel-hardening] " Alexei Starovoitov 2016-08-27 7:30 ` Andy Lutomirski 2016-08-27 7:30 ` [kernel-hardening] " Andy Lutomirski 2016-08-27 7:30 ` Andy Lutomirski 2016-08-27 18:11 ` Alexei Starovoitov 2016-08-27 18:11 ` [kernel-hardening] " Alexei Starovoitov 2016-08-28 8:14 ` Andy Lutomirski 2016-08-28 8:14 ` [kernel-hardening] " Andy Lutomirski 2016-08-28 8:14 ` Andy Lutomirski 2016-08-27 14:06 ` [RFC v2 09/10] landlock: Handle cgroups (performance) Mickaël Salaün 2016-08-27 14:06 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 18:06 ` Alexei Starovoitov 2016-08-27 18:06 ` [kernel-hardening] " Alexei Starovoitov 2016-08-27 18:06 ` Alexei Starovoitov 2016-08-27 19:35 ` Mickaël Salaün 2016-08-27 19:35 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 20:43 ` Alexei Starovoitov 2016-08-27 20:43 ` [kernel-hardening] " Alexei Starovoitov 2016-08-27 20:43 ` Alexei Starovoitov 2016-08-27 21:14 ` Mickaël Salaün 2016-08-27 21:14 ` [kernel-hardening] " Mickaël Salaün 2016-08-28 8:13 ` Andy Lutomirski 2016-08-28 8:13 ` [kernel-hardening] " Andy Lutomirski 2016-08-28 8:13 ` Andy Lutomirski 2016-08-28 9:42 ` Mickaël Salaün 2016-08-28 9:42 ` [kernel-hardening] " Mickaël Salaün 2016-08-28 9:42 ` Mickaël Salaün 2016-08-30 18:55 ` Andy Lutomirski 2016-08-30 18:55 ` [kernel-hardening] " Andy Lutomirski 2016-08-30 18:55 ` Andy Lutomirski 2016-08-30 20:20 ` Mickaël Salaün 2016-08-30 20:20 ` [kernel-hardening] " Mickaël Salaün 2016-08-30 20:20 ` Mickaël Salaün 2016-08-30 20:23 ` Andy Lutomirski 2016-08-30 20:23 ` [kernel-hardening] " Andy Lutomirski 2016-08-30 20:23 ` Andy Lutomirski 2016-08-30 20:33 ` Mickaël Salaün 2016-08-30 20:33 ` [kernel-hardening] " Mickaël Salaün 2016-08-30 20:33 ` Mickaël Salaün 2016-08-30 20:55 ` Alexei Starovoitov 2016-08-30 20:55 ` [kernel-hardening] " Alexei Starovoitov 2016-08-30 20:55 ` Alexei Starovoitov 2016-08-30 21:45 ` Andy Lutomirski 2016-08-30 21:45 ` [kernel-hardening] " Andy Lutomirski 2016-08-30 21:45 ` Andy Lutomirski 2016-08-31 1:36 ` Alexei Starovoitov 2016-08-31 1:36 ` [kernel-hardening] " Alexei Starovoitov 2016-08-31 3:29 ` Andy Lutomirski 2016-08-31 3:29 ` Andy Lutomirski 2016-08-31 3:29 ` [kernel-hardening] " Andy Lutomirski 2016-08-31 3:29 ` Andy Lutomirski 2016-08-27 14:19 ` [RFC v2 09/10] landlock: Handle cgroups (netfilter match) Mickaël Salaün 2016-08-27 14:19 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 18:32 ` Alexei Starovoitov 2016-08-27 18:32 ` [kernel-hardening] " Alexei Starovoitov 2016-08-27 18:32 ` Alexei Starovoitov 2016-08-27 14:34 ` [RFC v2 09/10] landlock: Handle cgroups (program types) Mickaël Salaün 2016-08-27 14:34 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 18:19 ` Alexei Starovoitov 2016-08-27 18:19 ` [kernel-hardening] " Alexei Starovoitov 2016-08-27 19:55 ` Mickaël Salaün 2016-08-27 19:55 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 20:56 ` Alexei Starovoitov 2016-08-27 20:56 ` [kernel-hardening] " Alexei Starovoitov 2016-08-27 20:56 ` Alexei Starovoitov 2016-08-27 21:18 ` Mickaël Salaün 2016-08-27 21:18 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 10:32 ` [RFC v2 10/10] samples/landlock: Add sandbox example Mickaël Salaün 2016-08-25 10:32 ` [kernel-hardening] " Mickaël Salaün 2016-08-25 11:05 ` [RFC v2 00/10] Landlock LSM: Unprivileged sandboxing Andy Lutomirski 2016-08-25 11:05 ` [kernel-hardening] " Andy Lutomirski 2016-08-25 11:05 ` Andy Lutomirski 2016-08-25 13:57 ` Mickaël Salaün 2016-08-25 13:57 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 7:40 ` Andy Lutomirski 2016-08-27 7:40 ` [kernel-hardening] " Andy Lutomirski 2016-08-27 7:40 ` Andy Lutomirski 2016-08-27 15:10 ` Mickaël Salaün 2016-08-27 15:10 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 15:21 ` [RFC v2 00/10] Landlock LSM: Unprivileged sandboxing (cgroup delegation) Mickaël Salaün 2016-08-27 15:21 ` [kernel-hardening] " Mickaël Salaün 2016-08-27 15:21 ` Mickaël Salaün 2016-08-27 15:21 ` Mickaël Salaün 2016-08-30 16:06 ` [RFC v2 00/10] Landlock LSM: Unprivileged sandboxing Andy Lutomirski 2016-08-30 16:06 ` [kernel-hardening] " Andy Lutomirski 2016-08-30 16:06 ` Andy Lutomirski 2016-08-30 16:06 ` Andy Lutomirski 2016-08-30 19:51 ` Mickaël Salaün 2016-08-30 19:51 ` [kernel-hardening] " Mickaël Salaün 2016-08-30 19:51 ` Mickaël Salaün 2016-08-30 19:55 ` Andy Lutomirski 2016-08-30 19:55 ` [kernel-hardening] " Andy Lutomirski 2016-08-30 19:55 ` Andy Lutomirski 2016-08-30 19:55 ` Andy Lutomirski 2016-09-15 9:19 ` Pavel Machek 2016-09-15 9:19 ` [kernel-hardening] " Pavel Machek 2016-09-20 17:08 ` Mickaël Salaün 2016-09-20 17:08 ` [kernel-hardening] " Mickaël Salaün 2016-09-24 7:45 ` Pavel Machek 2016-09-24 7:45 ` [kernel-hardening] " Pavel Machek 2016-09-24 7:45 ` Pavel Machek 2016-10-03 22:56 ` Kees Cook 2016-10-03 22:56 ` [kernel-hardening] " Kees Cook 2016-10-03 22:56 ` Kees Cook 2016-10-03 22:56 ` Kees Cook 2016-10-05 20:30 ` Mickaël Salaün 2016-10-05 20:30 ` [kernel-hardening] " Mickaël Salaün 2016-10-05 20:30 ` Mickaël Salaün 2016-10-05 20:30 ` Mickaël Salaün
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=1472121165-29071-9-git-send-email-mic@digikod.net \ --to=mic@digikod.net \ --cc=arnd@arndb.de \ --cc=ast@kernel.org \ --cc=casey@schaufler-ca.com \ --cc=daniel@iogearbox.net \ --cc=daniel@zonque.org \ --cc=davem@davemloft.net \ --cc=drysdale@google.com \ --cc=elena.reshetova@intel.com \ --cc=james.l.morris@oracle.com \ --cc=keescook@chromium.org \ --cc=kernel-hardening@lists.openwall.com \ --cc=linux-api@vger.kernel.org \ --cc=linux-kernel@vger.kernel.org \ --cc=linux-security-module@vger.kernel.org \ --cc=luto@amacapital.net \ --cc=netdev@vger.kernel.org \ --cc=pmoore@redhat.com \ --cc=sargun@sargun.me \ --cc=serge@hallyn.com \ --cc=wad@chromium.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.