mm/memfd: introduce MFD_NOEXEC_SEAL and MFD_EXEC
Subsystems (6)
v5 cover mm/memfd: introduce MFD_NOEXEC_SEAL and MFD_EXEC
From: Jeff Xu <[email protected]>
Since Linux introduced the memfd feature, memfd have always had their execute bit set, and the memfd_create() syscall doesn't allow setting it differently.
However, in a secure by default system, such as ChromeOS, (where all executables should come from the rootfs, which is protected by Verified boot), this executable nature of memfd opens a door for NoExec bypass and enables “confused deputy attack”. E.g, in VRP bug [1]: cros_vm process created a memfd to share the content with an external process, however the memfd is overwritten and used for executing arbitrary code and root escalation. [2] lists more VRP in this kind.
On the other hand, executable memfd has its legit use, runc uses memfd’s seal and executable feature to copy the contents of the binary then execute them, for such system, we need a solution to differentiate runc's use of executable memfds and an attacker's [3].
To address those above, this set of patches add following:
1> Let memfd_create() set X bit at creation time.
2> Let memfd to be sealed for modifying X bit.
3> A new pid namespace sysctl: vm.memfd_noexec to control behavior of X bit. For example, if a container has vm.memfd_noexec=2, then memfd_create() without MFD_NOEXEC_SEAL will be rejected. 4> A new security hook in memfd_create(). This make it possible to a new LSM, which rejects or allows executable memfd based on its security policy.
This is V4 version of patch: see [4] [5] [6] for previous versions.
[1] https://crbug.com/1305411
[2] https://bugs.chromium.org/p/chromium/issues/list?q=type%3Dbug-security%20memfd%20escalation&can=1
[3] https://lwn.net/Articles/781013/
[4] https://lwn.net/Articles/890096/
[5] https://lore.kernel.org/lkml/[email protected]/
[6] https://lore.kernel.org/lkml/[email protected]/
Daniel Verkamp (2):
mm/memfd: add F_SEAL_EXEC
selftests/memfd: add tests for F_SEAL_EXEC
Jeff Xu (4):
mm/memfd: add MFD_NOEXEC_SEAL and MFD_EXEC
mm/memfd: Add write seals when apply SEAL_EXEC to executable memfd selftests/memfd: add tests for MFD_NOEXEC_SEAL MFD_EXEC mm/memfd: security hook for memfd_create
include/linux/lsm_hook_defs.h | 1 + include/linux/lsm_hooks.h | 4 + include/linux/pid_namespace.h | 19 ++ include/linux/security.h | 6 + include/uapi/linux/fcntl.h | 1 + include/uapi/linux/memfd.h | 4 + kernel/pid_namespace.c | 48 ++++ mm/memfd.c | 61 ++++- mm/shmem.c | 6 + security/security.c | 13 + tools/testing/selftests/memfd/fuse_test.c | 1 + tools/testing/selftests/memfd/memfd_test.c | 304 ++++++++++++++++++++- 12 files changed, 465 insertions(+), 3 deletions(-)
base-commit: eb7081409f94a9a8608593d0fb63a1aa3d6f95d8
Signature · 1 line
2.39.0.rc0.267.gcb52ba06e7-goog
PATCH v5 1/6 mm/memfd: add F_SEAL_EXEC
From: Daniel Verkamp <[email protected]>
The new F_SEAL_EXEC flag will prevent modification of the exec bits:
written as traditional octal mask, 0111, or as named flags, S_IXUSR | S_IXGRP | S_IXOTH. Any chmod(2) or similar call that attempts to modify any of these bits after the seal is applied will fail with errno EPERM.
This will preserve the execute bits as they are at the time of sealing, so the memfd will become either permanently executable or permanently un-executable.
--- include/uapi/linux/fcntl.h | 1 + mm/memfd.c | 2 ++ mm/shmem.c | 6 ++++++ 3 files changed, 9 insertions(+)
include/uapi/linux/fcntl.h +1 -0
@@ -43,6 +43,7 @@#define F_SEAL_GROW 0x0004/* prevent file from growing */ #define F_SEAL_WRITE 0x0008/* prevent writes */ #define F_SEAL_FUTURE_WRITE 0x0010/* prevent future writes while mapped */ +#define F_SEAL_EXEC 0x0020/* prevent chmod modifying exec bits */ /* (1U << 31) is reserved for signed error codes */ /*
mm/memfd.c +2 -0
@@ -147,6 +147,7 @@ static unsigned int *memfd_file_seals_ptr(struct file *file) }#define F_ALL_SEALS (F_SEAL_SEAL | \ + F_SEAL_EXEC | \ F_SEAL_SHRINK | \ F_SEAL_GROW | \ F_SEAL_WRITE | \
@@ -175,6 +176,7 @@ static int memfd_add_seals(struct file *file, unsigned int seals)* SEAL_SHRINK: Prevent the file from shrinking * SEAL_GROW: Prevent the file from growing * SEAL_WRITE: Prevent write access to the file +* SEAL_EXEC: Prevent modification of the exec bits in the file mode * * As we don't require any trust relationship between two parties, we * must prevent seals from being removed. Therefore, sealing a file
mm/shmem.c +6 -0
@@ -1085,6 +1085,12 @@ static int shmem_setattr(struct user_namespace *mnt_userns,if (error)return error; +if ((info->seals &F_SEAL_EXEC ) && (attr->ia_valid &ATTR_MODE )) { +if ((inode->i_mode ^ attr->ia_mode) &0111 ) { +return -EPERM ; + } + } +if (S_ISREG (inode->i_mode) && (attr->ia_valid &ATTR_SIZE )) {loff_t oldsize = inode->i_size;loff_t newsize = attr->ia_size;
Signature · 1 line
2.39.0.rc0.267.gcb52ba06e7-goog
PATCH v5 2/6 selftests/memfd: add tests for F_SEAL_EXEC
In reply to [email protected]From: Daniel Verkamp <[email protected]>
Basic tests to ensure that user/group/other execute bits cannot be changed after applying F_SEAL_EXEC to a memfd.
--- tools/testing/selftests/memfd/memfd_test.c | 129 ++++++++++++++++++++- 1 file changed, 128 insertions(+), 1 deletion(-)
tools/testing/selftests/memfd/memfd_test.c +128 -1
@@ -28,12 +28,44 @@#define MFD_DEF_SIZE 8192#define STACK_SIZE 65536 +#ifndef F_SEAL_EXEC +#define F_SEAL_EXEC 0x0020 +#endif + +#ifndef MAX_PATH +#define MAX_PATH 256 +#endif +/* * Default is not to test hugetlbfs */ static size_t mfd_def_size =MFD_DEF_SIZE ;static const char *memfd_str =MEMFD_STR ; +static ssize_t fd2name (int fd,char *buf,size_t bufsize) +{ +char buf1[MAX_PATH ]; +int size; +ssize_t nbytes; + + size =snprintf (buf1,MAX_PATH ,"/proc/self/fd/%d" , fd); +if (size <0 ) { +printf ("snprintf(%d) failed on %m\n" , fd); +abort (); + } + +/* +* reserver one byte for string termination. +*/ + nbytes =readlink (buf1, buf, bufsize-1 ); +if (nbytes ==-1 ) { +printf ("readlink(%s) failed %m\n" , buf1); +abort (); + } + buf[nbytes] ='\0' ; +return nbytes; +} +static int mfd_assert_new (const char *name,loff_t sz,unsigned int flags) {int r, fd;
@@ -98,11 +130,14 @@ static unsigned int mfd_assert_get_seals(int fd)static void mfd_assert_has_seals (int fd,unsigned int seals) { +char buf[MAX_PATH ]; +int nbytes;unsigned int s; +fd2name (fd, buf,MAX_PATH ); s =mfd_assert_get_seals (fd);if (s != seals) { -printf ("%u != %u = GET_SEALS(%d)\n" , seals, s, fd); +printf ("%u != %u = GET_SEALS(%s)\n" , seals, s, buf);abort (); } }
@@ -594,6 +629,64 @@ static void mfd_fail_grow_write(int fd) } } +static void mfd_assert_mode (int fd,int mode) +{ +struct stat st; +char buf[MAX_PATH ]; +int nbytes; + +fd2name (fd, buf,MAX_PATH ); + +if (fstat (fd, &st) <0 ) { +printf ("fstat(%s) failed: %m\n" , buf); +abort (); + } + +if ((st.st_mode &07777 ) != mode) { +printf ("fstat(%s) wrong file mode 0%04o, but expected 0%04o\n" , + buf, (int )st.st_mode &07777 , mode); +abort (); + } +} + +static void mfd_assert_chmod (int fd,int mode) +{ +char buf[MAX_PATH ]; +int nbytes; + +fd2name (fd, buf,MAX_PATH ); + +if (fchmod (fd, mode) <0 ) { +printf ("fchmod(%s, 0%04o) failed: %m\n" , buf, mode); +abort (); + } + +mfd_assert_mode (fd, mode); +} + +static void mfd_fail_chmod (int fd,int mode) +{ +struct stat st; +char buf[MAX_PATH ]; +int nbytes; + +fd2name (fd, buf,MAX_PATH ); + +if (fstat (fd, &st) <0 ) { +printf ("fstat(%s) failed: %m\n" , buf); +abort (); + } + +if (fchmod (fd, mode) ==0 ) { +printf ("fchmod(%s, 0%04o) didn't fail as expected\n" , + buf, mode); +abort (); + } + +/* verify that file mode bits did not change */ +mfd_assert_mode (fd, st.st_mode &07777 ); +} +static int idle_thread_fn (void *arg) {sigset_t set;
@@ -880,6 +973,39 @@ static void test_seal_resize(void)close (fd); } +/* +* Test SEAL_EXEC +* Test that chmod() cannot change x bits after sealing +*/ +static void test_seal_exec (void ) +{ +int fd; + +printf ("%s SEAL-EXEC\n" , memfd_str); + + fd =mfd_assert_new ("kern_memfd_seal_exec" , + mfd_def_size, +MFD_CLOEXEC |MFD_ALLOW_SEALING ); + +mfd_assert_mode (fd,0777 ); + +mfd_assert_chmod (fd,0644 ); + +mfd_assert_has_seals (fd,0 ); +mfd_assert_add_seals (fd,F_SEAL_EXEC ); +mfd_assert_has_seals (fd,F_SEAL_EXEC ); + +mfd_assert_chmod (fd,0600 ); +mfd_fail_chmod (fd,0777 ); +mfd_fail_chmod (fd,0670 ); +mfd_fail_chmod (fd,0605 ); +mfd_fail_chmod (fd,0700 ); +mfd_fail_chmod (fd,0100 ); +mfd_assert_chmod (fd,0666 ); + +close (fd); +} +/* * Test sharing via dup() * Test that seals are shared between dupped FDs and they're all equal.
@@ -1059,6 +1185,7 @@ int main(int argc, char **argv)test_seal_shrink ();test_seal_grow ();test_seal_resize (); +test_seal_exec ();test_share_dup ("SHARE-DUP" ,"" );test_share_mmap ("SHARE-MMAP" ,"" );
Signature · 1 line
2.39.0.rc0.267.gcb52ba06e7-goog
PATCH v5 3/6 mm/memfd: add MFD_NOEXEC_SEAL and MFD_EXEC
In reply to [email protected]From: Jeff Xu <[email protected]>
The new MFD_NOEXEC_SEAL and MFD_EXEC flags allows application to set executable bit at creation time (memfd_create).
When MFD_NOEXEC_SEAL is set, memfd is created without executable bit (mode:0666), and sealed with F_SEAL_EXEC, so it can't be chmod to be executable (mode: 0777) after creation.
when MFD_EXEC flag is set, memfd is created with executable bit (mode:0777), this is the same as the old behavior of memfd_create.
The new pid namespaced sysctl vm.memfd_noexec has 3 values:
0: memfd_create() without MFD_EXEC nor MFD_NOEXEC_SEAL acts like
MFD_EXEC was set.
1: memfd_create() without MFD_EXEC nor MFD_NOEXEC_SEAL acts like
MFD_NOEXEC_SEAL was set.
2: memfd_create() without MFD_NOEXEC_SEAL will be rejected.
The sysctl allows finer control of memfd_create for old-software that doesn't set the executable bit, for example, a container with vm.memfd_noexec=1 means the old-software will create non-executable memfd by default.
--- include/linux/pid_namespace.h | 19 ++++++++++++++ include/uapi/linux/memfd.h | 4 +++ kernel/pid_namespace.c | 48 +++++++++++++++++++++++++++++++++++ mm/memfd.c | 48 +++++++++++++++++++++++++++++++++-- 4 files changed, 117 insertions(+), 2 deletions(-)
include/linux/pid_namespace.h +19 -0
@@ -16,6 +16,21 @@struct fs_pin ; +#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE ) +/* +* sysctl for vm.memfd_noexec +* 0: memfd_create() without MFD_EXEC nor MFD_NOEXEC_SEAL +* acts like MFD_EXEC was set. +* 1: memfd_create() without MFD_EXEC nor MFD_NOEXEC_SEAL +* acts like MFD_NOEXEC_SEAL was set. +* 2: memfd_create() without MFD_NOEXEC_SEAL will be +* rejected. +*/ +#define MEMFD_NOEXEC_SCOPE_EXEC 0 +#define MEMFD_NOEXEC_SCOPE_NOEXEC_SEAL 1 +#define MEMFD_NOEXEC_SCOPE_NOEXEC_ENFORCED 2 +#endif +struct pid_namespace {struct idr idr;struct rcu_head rcu;
@@ -31,6 +46,10 @@ struct pid_namespace {struct ucounts *ucounts;int reboot;/* group exit code if this pidns was rebooted */ struct ns_common ns; +#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE ) +/* sysctl for vm.memfd_noexec */ +int memfd_noexec_scope; +#endif } __randomize_layout;extern struct pid_namespace init_pid_ns;
include/uapi/linux/memfd.h +4 -0
@@ -8,6 +8,10 @@#define MFD_CLOEXEC 0x0001U#define MFD_ALLOW_SEALING 0x0002U#define MFD_HUGETLB 0x0004U +/* not executable and sealed to prevent changing to executable. */ +#define MFD_NOEXEC_SEAL 0x0008U +/* executable */ +#define MFD_EXEC 0x0010U/* * Huge page size encoding when MFD_HUGETLB is specified, and a huge page
kernel/pid_namespace.c +48 -0
66 lines not on this page · raw message
mm/memfd.c +46 -2
77 lines not on this page · raw message
Signature · 1 line
2.39.0.rc0.267.gcb52ba06e7-goog
Re: [PATCH v5 3/6] mm/memfd: add MFD_NOEXEC_SEAL and MFD_EXEC
kernel/pid_namespace.c static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns · line 116
Quoted 10 lines · On Tue, Dec 06, 2022 at 03:23:55PM +0000, [email protected] wrote:
kernel/pid_namespace.c +4
-0@@ -110,6 +110,11 @@ static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns ns->ucounts = ucounts; ns->pid_allocated =PIDNS_ADDING ; +#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE ) + ns->memfd_noexec_scope = +task_active_pid_ns (current)->memfd_noexec_scope; +#endif
.c files should never have #if in them. Can't you put this in a .h file properly so that this does not get really messy over time?
kernel/pid_namespace.c void zap_pid_ns_processes(struct pid_namespace *pid_ns) · line 263
Quoted 9 lines
kernel/pid_namespace.c +2
-0+return ns; out_free_idr:@@ -255,6 +260,45 @@ void zap_pid_ns_processes(struct pid_namespace *pid_ns)return ; } +#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE )
Same here.
thanks,
greg k-h
Re: [PATCH v5 3/6] mm/memfd: add MFD_NOEXEC_SEAL and MFD_EXEC
Quoted 8 lines · Greg KH
Quoted 6 lines · On Tue, Dec 06, 2022 at 03:23:55PM +0000, [email protected] wrote:
kernel/pid_namespace.c +0
-0@@ -110,6 +110,11 @@ static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns ns->ucounts = ucounts; ns->pid_allocated =PIDNS_ADDING ;
Quoted 9 lines
kernel/pid_namespace.c static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns · line 116
Quoted 4 lines
kernel/pid_namespace.c +4
-0+#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE ) + ns->memfd_noexec_scope = +task_active_pid_ns (current)->memfd_noexec_scope; +#endif .c files should never have #if in them. Can't you put this in a .h file properly so that this does not get really messy over time?
Thanks for reviewing.
It seems to me that checking for CONFIG_XXX is common in c code in kernel/ path.
Do you have a sample code pattern (link/function) that I can follow?
Thanks
Jeff
Quoted 16 lines
kernel/pid_namespace.c void zap_pid_ns_processes(struct pid_namespace *pid_ns) · line 263
Quoted 10 lines
kernel/pid_namespace.c +2
-0+return ns; out_free_idr:@@ -255,6 +260,45 @@ void zap_pid_ns_processes(struct pid_namespace *pid_ns)return ; } +#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE )Same here.
thanks,
greg k-h
Re: [PATCH v5 3/6] mm/memfd: add MFD_NOEXEC_SEAL and MFD_EXEC
Quoted 18 lines · Jeff Xu
Quoted 8 lines · Greg KH
Quoted 6 lines · On Tue, Dec 06, 2022 at 03:23:55PM +0000, [email protected] wrote:
kernel/pid_namespace.c +0
-0@@ -110,6 +110,11 @@ static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns ns->ucounts = ucounts; ns->pid_allocated =PIDNS_ADDING ;Quoted 9 lines
kernel/pid_namespace.c static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns · line 116
Quoted 4 lines
kernel/pid_namespace.c +4
-0+#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE ) + ns->memfd_noexec_scope = +task_active_pid_ns (current)->memfd_noexec_scope; +#endif .c files should never have #if in them. Can't you put this in a .h file properly so that this does not get really messy over time?
Quoted 3 lines
Thanks for reviewing.
It seems to me that checking forCONFIG_XXXis common in c code inkernel/path.
Maybe, but please don't make it any worse if at all possible. It's tough to maintain code like that.
Quoted 1 line
Do you have a sample code pattern (link/function) that I can follow?
Any of the zillions of #if statements in .h files :)
thanks,
greg k-h
Re: [PATCH v5 3/6] mm/memfd: add MFD_NOEXEC_SEAL and MFD_EXEC
Quoted 24 lines · Greg KH
Quoted 18 lines · Jeff Xu
Quoted 8 lines · Greg KH
Quoted 6 lines · On Tue, Dec 06, 2022 at 03:23:55PM +0000, [email protected] wrote:
kernel/pid_namespace.c +0
-0@@ -110,6 +110,11 @@ static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns ns->ucounts = ucounts; ns->pid_allocated =PIDNS_ADDING ;Quoted 9 lines
kernel/pid_namespace.c static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns · line 116
Quoted 4 lines
kernel/pid_namespace.c +4
-0+#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE ) + ns->memfd_noexec_scope = +task_active_pid_ns (current)->memfd_noexec_scope; +#endif .c files should never have #if in them. Can't you put this in a .h file properly so that this does not get really messy over time?
Quoted 3 lines
Thanks for reviewing.
It seems to me that checking forCONFIG_XXXis common in c code inkernel/path.
Quoted 7 lines
Maybe, but please don't make it any worse if at all possible. It's tough to maintain code like that.
Quoted 1 line
Do you have a sample code pattern (link/function) that I can follow?
Any of the zillions of #if statements in .h files :)
Thanks.
I will take the approach of having real/stub implementation in the h file, and the c file using it without a compile flag. Please kindly let me know if this is not right.
Thanks
Jeff
Quoted 3 lines
thanks,
greg k-h
Re: [PATCH v5 3/6] mm/memfd: add MFD_NOEXEC_SEAL and MFD_EXEC
Quoted 28 lines · Jeff Xu
Quoted 27 lines · Greg KH
Quoted 18 lines · Jeff Xu
Quoted 8 lines · Greg KH
Quoted 6 lines · On Tue, Dec 06, 2022 at 03:23:55PM +0000, [email protected] wrote:
kernel/pid_namespace.c +0
-0@@ -110,6 +110,11 @@ static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns ns->ucounts = ucounts; ns->pid_allocated =PIDNS_ADDING ;Quoted 9 lines
kernel/pid_namespace.c static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns · line 116
Quoted 4 lines
kernel/pid_namespace.c +4
-0+#if defined(CONFIG_SYSCTL ) && defined(CONFIG_MEMFD_CREATE ) + ns->memfd_noexec_scope = +task_active_pid_ns (current)->memfd_noexec_scope; +#endif .c files should never have #if in them. Can't you put this in a .h file properly so that this does not get really messy over time?
Quoted 3 lines
Thanks for reviewing.
It seems to me that checking forCONFIG_XXXis common in c code inkernel/path.Maybe, but please don't make it any worse if at all possible. It's tough to maintain code like that.
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Do you have a sample code pattern (link/function) that I can follow?
Any of the zillions of #if statements in .h files :)
Thanks.
I will take the approach of having real/stub implementation in the h file, and the c file using it without a compile flag. Please kindly let me know if this is not right.
Right; for example:
in .h:
#if defined(CONFIG_SYSCTL) && defined(CONFIG_MEMFD_CREATE) static inline void ns_copy_memfd_scope(... dst, ... src) {
dst->memfd_noexec_scope = src->memfd_noexec_scope; }
#else
static inline void ns_set_memfd_scope(... ns, ... scope) { } #endif
in .c:
ns_copy_memfd_scope(ns, task_active_pid_ns(current));
Signature · 1 line
Kees Cook
PATCH v5 4/6 mm/memfd: Add write seals when apply SEAL_EXEC to executable memfd
In reply to [email protected]From: Jeff Xu <[email protected]>
In order to avoid WX mappings, add F_SEAL_WRITE when apply F_SEAL_EXEC to an executable memfd, so W^X from start.
This implys application need to fill the content of the memfd first, after F_SEAL_EXEC is applied, application can no longer modify the content of the memfd.
Typically, application seals the memfd right after writing to it. For example:
1. memfd_create(MFD_EXEC).
2. write() code to the memfd.
3. fcntl(F_ADD_SEALS, F_SEAL_EXEC) to convert the memfd to W^X.
4. call exec() on the memfd.
--- mm/memfd.c | 6 ++++++ 1 file changed, 6 insertions(+)
mm/memfd.c +6 -0
@@ -222,6 +222,12 @@ static int memfd_add_seals(struct file *file, unsigned int seals) } } +/* +* SEAL_EXEC implys SEAL_WRITE, making W^X from the start. +*/ +if (seals &F_SEAL_EXEC && inode->i_mode &0111 ) + seals |=F_SEAL_SHRINK |F_SEAL_GROW |F_SEAL_WRITE |F_SEAL_FUTURE_WRITE ; + *file_seals |= seals; error =0 ;
Signature · 1 line
2.39.0.rc0.267.gcb52ba06e7-goog
PATCH v5 5/6 selftests/memfd: add tests for MFD_NOEXEC_SEAL MFD_EXEC
In reply to [email protected]From: Jeff Xu <[email protected]>
Tests to verify MFD_NOEXEC, MFD_EXEC and vm.memfd_noexec sysctl.
Change-Id: Idccec1141255ca948c849f4efc8ba5e97f78b6eb
--- tools/testing/selftests/memfd/fuse_test.c | 1 + tools/testing/selftests/memfd/memfd_test.c | 185 ++++++++++++++++++++- 2 files changed, 181 insertions(+), 5 deletions(-)
tools/testing/selftests/memfd/fuse_test.c +1 -0
@@ -22,6 +22,7 @@#include <linux/falloc.h> #include <fcntl.h> #include <linux/memfd.h> +#include <linux/types.h> #include <sched.h> #include <stdio.h> #include <stdlib.h>
tools/testing/selftests/memfd/memfd_test.c +180 -5
251 lines not on this page · raw message
Signature · 1 line
2.39.0.rc0.267.gcb52ba06e7-goog
Re: [PATCH v5 5/6] selftests/memfd: add tests for MFD_NOEXEC_SEAL MFD_EXEC
Quoted 9 lines · On Tue, Dec 06, 2022 at 03:23:57PM +0000, [email protected] wrote:
From: Jeff Xu <[email protected]>
Tests to verify
MFD_NOEXEC,MFD_EXECand vm.memfd_noexec sysctl.Signed-off-by Jeff Xu <[email protected]>Co-developed-by Daniel Verkamp <[email protected]>Signed-off-by Daniel Verkamp <[email protected]>Change-Id: Idccec1141255ca948c849f4efc8ba5e97f78b6eb
Always use checkpatch.pl on your patches so you don't get grumpy maintainers telling you to run checkpatch.pl on your patches...
thanks,
greg k-h
Re: [PATCH v5 5/6] selftests/memfd: add tests for MFD_NOEXEC_SEAL MFD_EXEC
Quoted 5 lines · Greg KH
Quoted 4 lines · On Tue, Dec 06, 2022 at 03:23:57PM +0000, [email protected] wrote:
From: Jeff Xu <[email protected]>
Tests to verify
MFD_NOEXEC,MFD_EXECand vm.memfd_noexec sysctl.
Quoted 10 lines
Quoted 5 lines
Signed-off-by Jeff Xu <[email protected]>Co-developed-by Daniel Verkamp <[email protected]>Signed-off-by Daniel Verkamp <[email protected]>Change-Id: Idccec1141255ca948c849f4efc8ba5e97f78b6eb
Always use checkpatch.pl on your patches so you don't get grumpy maintainers telling you to run checkpatch.pl on your patches...
Will do, thanks for pointing it out.
Jeff
Quoted 4 lines
thanks,
greg k-h
PATCH v5 6/6 mm/memfd: security hook for memfd_create
In reply to [email protected]From: Jeff Xu <[email protected]>
The new security_memfd_create allows lsm to check flags of memfd_create.
The security by default system (such as chromeos) can use this to implement system wide lsm to allow only non-executable memfd being created.
--- include/linux/lsm_hook_defs.h | 1 + include/linux/lsm_hooks.h | 4 ++++ include/linux/security.h | 6 ++++++ mm/memfd.c | 5 +++++ security/security.c | 13 +++++++++++++ 5 files changed, 29 insertions(+)
include/linux/lsm_hook_defs.h +1 -0
@@ -164,6 +164,7 @@ LSM_HOOK(int, 0, file_alloc_security, struct file *file) LSM_HOOK(void, LSM_RET_VOID, file_free_security, struct file *file) LSM_HOOK(int, 0, file_ioctl, struct file *file, unsigned int cmd, unsigned long arg) +LSM_HOOK(int, 0, memfd_create, char *name, unsigned int flags) LSM_HOOK(int, 0, mmap_addr, unsigned long addr) LSM_HOOK(int, 0, mmap_file, struct file *file, unsigned long reqprot, unsigned long prot, unsigned long flags)
include/linux/lsm_hooks.h +4 -0
@@ -543,6 +543,10 @@* simple integer value. When @arg represents a user space pointer, it * should never be used by the security module. * Return 0 if permission is granted. +* @memfd_create: +* @name is the name of memfd file. +* @flags is the flags used in memfd_create. +* Return 0 if permission is granted. * @mmap_addr : * Check permissions for a mmap operation at @addr. * @addr contains virtual address that will be used for the operation.
include/linux/security.h +6 -0
@@ -384,6 +384,7 @@ int security_file_permission(struct file *file, int mask);int security_file_alloc (struct file *file);void security_file_free (struct file *file);int security_file_ioctl (struct file *file,unsigned int cmd,unsigned long arg); +int security_memfd_create (char *name,unsigned int flags);int security_mmap_file (struct file *file,unsigned long prot,unsigned long flags);int security_mmap_addr (unsigned long addr);
@@ -963,6 +964,11 @@ static inline int security_file_ioctl(struct file *file, unsigned int cmd,return 0 ; } +static inline int security_memfd_create (char *name,unsigned int flags) +{ +return 0 ; +} +static inline int security_mmap_file (struct file *file,unsigned long prot,unsigned long flags) {
mm/memfd.c +5 -0
@@ -356,6 +356,11 @@ SYSCALL_DEFINE2(memfd_create, goto err_name; } +/* security hook for memfd_create */ + error =security_memfd_create (name, flags); +if (error) +return error; +if (flags &MFD_HUGETLB ) { file = hugetlb_file_setup(name, 0, VM_NORESERVE, HUGETLB_ANONHUGE_INODE,
security/security.c +13 -0
@@ -1010,6 +1010,19 @@ int security_sb_clone_mnt_opts(const struct super_block *oldsb, }EXPORT_SYMBOL (security_sb_clone_mnt_opts); +int security_add_mnt_opt (const char *option,const char *val,int len, +void **mnt_opts) +{ +return call_int_hook (sb_add_mnt_opt, -EINVAL , + option, val, len, mnt_opts); +} +EXPORT_SYMBOL (security_add_mnt_opt); + +int security_memfd_create (char *name,unsigned int flags) +{ +return call_int_hook (memfd_create,0 , name, flags); +} +int security_move_mount (const struct path *from_path,const struct path *to_path) {return call_int_hook (move_mount,0 , from_path, to_path);
Signature · 1 line
2.39.0.rc0.267.gcb52ba06e7-goog