selftests/memfd: add tests for MFD_NOEXEC_SEAL MFD_EXEC

Tests to verify MFD_NOEXEC, MFD_EXEC and vm.memfd_noexec sysctl.

Link: https://lkml.kernel.org/r/20221215001205.51969-6-jeffxu@google.com
Signed-off-by: Jeff Xu <jeffxu@google.com>
Co-developed-by: Daniel Verkamp <dverkamp@chromium.org>
Signed-off-by: Daniel Verkamp <dverkamp@chromium.org>
Reviewed-by: Kees Cook <keescook@chromium.org>
Cc: David Herrmann <dh.herrmann@gmail.com>
Cc: Dmitry Torokhov <dmitry.torokhov@gmail.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Jann Horn <jannh@google.com>
Cc: Jorge Lucangeli Obes <jorgelo@chromium.org>
Cc: kernel test robot <lkp@intel.com>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/tools/testing/selftests/memfd/fuse_test.c b/tools/testing/selftests/memfd/fuse_test.c
index be675002f918a0888d61c4196e06718d908a0ec2..93798c8c5d54b5760d353645da5047c18ea1ca21 100644 (file)
--- a/tools/testing/selftests/memfd/fuse_test.c
+++ b/tools/testing/selftests/memfd/fuse_test.c
@@ -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>

diff --git a/tools/testing/selftests/memfd/memfd_test.c b/tools/testing/selftests/memfd/memfd_test.c
index f18a15a1f275e02e7875834c2184bfd04bfce700..ae71f15f790dfda3b7f47ca7ccf74d7da38dfc5e 100644 (file)
--- a/tools/testing/selftests/memfd/memfd_test.c
+++ b/tools/testing/selftests/memfd/memfd_test.c
@@ -30,6 +30,14 @@
 
 #define F_SEAL_EXEC    0x0020
 
+#define F_WX_SEALS (F_SEAL_SHRINK | \
+                   F_SEAL_GROW | \
+                   F_SEAL_WRITE | \
+                   F_SEAL_FUTURE_WRITE | \
+                   F_SEAL_EXEC)
+
+#define MFD_NOEXEC_SEAL        0x0008U
+
 /*
  * Default is not to test hugetlbfs
  */
@@ -80,6 +88,37 @@ static int mfd_assert_new(const char *name, loff_t sz, unsigned int flags)
        return fd;
 }
 
+static void sysctl_assert_write(const char *val)
+{
+       int fd = open("/proc/sys/vm/memfd_noexec", O_WRONLY | O_CLOEXEC);
+
+       if (fd < 0) {
+               printf("open sysctl failed\n");
+               abort();
+       }
+
+       if (write(fd, val, strlen(val)) < 0) {
+               printf("write sysctl failed\n");
+               abort();
+       }
+}
+
+static void sysctl_fail_write(const char *val)
+{
+       int fd = open("/proc/sys/vm/memfd_noexec", O_WRONLY | O_CLOEXEC);
+
+       if (fd < 0) {
+               printf("open sysctl failed\n");
+               abort();
+       }
+
+       if (write(fd, val, strlen(val)) >= 0) {
+               printf("write sysctl %s succeeded, but failure expected\n",
+                               val);
+               abort();
+       }
+}
+
 static int mfd_assert_reopen_fd(int fd_in)
 {
        int fd;
@@ -758,6 +797,9 @@ static void test_create(void)
        mfd_fail_new("", ~0);
        mfd_fail_new("", 0x80000000U);
 
+       /* verify EXEC and NOEXEC_SEAL can't both be set */
+       mfd_fail_new("", MFD_EXEC | MFD_NOEXEC_SEAL);
+
        /* verify MFD_CLOEXEC is allowed */
        fd = mfd_assert_new("", 0, MFD_CLOEXEC);
        close(fd);
@@ -969,20 +1011,21 @@ static void test_seal_resize(void)
 
 /*
  * Test SEAL_EXEC
- * Test that chmod() cannot change x bits after sealing
+ * Test fd is created with exec and allow sealing.
+ * chmod() cannot change x bits after sealing.
  */
-static void test_seal_exec(void)
+static void test_exec_seal(void)
 {
        int fd;
 
        printf("%s SEAL-EXEC\n", memfd_str);
 
+       printf("%s      Apply SEAL_EXEC\n", memfd_str);
        fd = mfd_assert_new("kern_memfd_seal_exec",
                            mfd_def_size,
-                           MFD_CLOEXEC | MFD_ALLOW_SEALING);
+                           MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_EXEC);
 
        mfd_assert_mode(fd, 0777);
-
        mfd_assert_chmod(fd, 0644);
 
        mfd_assert_has_seals(fd, 0);
@@ -996,10 +1039,181 @@ static void test_seal_exec(void)
        mfd_fail_chmod(fd, 0700);
        mfd_fail_chmod(fd, 0100);
        mfd_assert_chmod(fd, 0666);
+       mfd_assert_write(fd);
+       close(fd);
+
+       printf("%s      Apply ALL_SEALS\n", memfd_str);
+       fd = mfd_assert_new("kern_memfd_seal_exec",
+                           mfd_def_size,
+                           MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_EXEC);
+
+       mfd_assert_mode(fd, 0777);
+       mfd_assert_chmod(fd, 0700);
+
+       mfd_assert_has_seals(fd, 0);
+       mfd_assert_add_seals(fd, F_SEAL_EXEC);
+       mfd_assert_has_seals(fd, F_WX_SEALS);
 
+       mfd_fail_chmod(fd, 0711);
+       mfd_fail_chmod(fd, 0600);
+       mfd_fail_write(fd);
+       close(fd);
+}
+
+/*
+ * Test EXEC_NO_SEAL
+ * Test fd is created with exec and not allow sealing.
+ */
+static void test_exec_no_seal(void)
+{
+       int fd;
+
+       printf("%s EXEC_NO_SEAL\n", memfd_str);
+
+       /* Create with EXEC but without ALLOW_SEALING */
+       fd = mfd_assert_new("kern_memfd_exec_no_sealing",
+                           mfd_def_size,
+                           MFD_CLOEXEC | MFD_EXEC);
+       mfd_assert_mode(fd, 0777);
+       mfd_assert_has_seals(fd, F_SEAL_SEAL);
+       mfd_assert_chmod(fd, 0666);
        close(fd);
 }
 
+/*
+ * Test memfd_create with MFD_NOEXEC flag
+ */
+static void test_noexec_seal(void)
+{
+       int fd;
+
+       printf("%s NOEXEC_SEAL\n", memfd_str);
+
+       /* Create with NOEXEC and ALLOW_SEALING */
+       fd = mfd_assert_new("kern_memfd_noexec",
+                           mfd_def_size,
+                           MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_NOEXEC_SEAL);
+       mfd_assert_mode(fd, 0666);
+       mfd_assert_has_seals(fd, F_SEAL_EXEC);
+       mfd_fail_chmod(fd, 0777);
+       close(fd);
+
+       /* Create with NOEXEC but without ALLOW_SEALING */
+       fd = mfd_assert_new("kern_memfd_noexec",
+                           mfd_def_size,
+                           MFD_CLOEXEC | MFD_NOEXEC_SEAL);
+       mfd_assert_mode(fd, 0666);
+       mfd_assert_has_seals(fd, F_SEAL_EXEC);
+       mfd_fail_chmod(fd, 0777);
+       close(fd);
+}
+
+static void test_sysctl_child(void)
+{
+       int fd;
+
+       printf("%s sysctl 0\n", memfd_str);
+       sysctl_assert_write("0");
+       fd = mfd_assert_new("kern_memfd_sysctl_0",
+                           mfd_def_size,
+                           MFD_CLOEXEC | MFD_ALLOW_SEALING);
+
+       mfd_assert_mode(fd, 0777);
+       mfd_assert_has_seals(fd, 0);
+       mfd_assert_chmod(fd, 0644);
+       close(fd);
+
+       printf("%s sysctl 1\n", memfd_str);
+       sysctl_assert_write("1");
+       fd = mfd_assert_new("kern_memfd_sysctl_1",
+                           mfd_def_size,
+                           MFD_CLOEXEC | MFD_ALLOW_SEALING);
+
+       mfd_assert_mode(fd, 0666);
+       mfd_assert_has_seals(fd, F_SEAL_EXEC);
+       mfd_fail_chmod(fd, 0777);
+       sysctl_fail_write("0");
+       close(fd);
+
+       printf("%s sysctl 2\n", memfd_str);
+       sysctl_assert_write("2");
+       mfd_fail_new("kern_memfd_sysctl_2",
+               MFD_CLOEXEC | MFD_ALLOW_SEALING);
+       sysctl_fail_write("0");
+       sysctl_fail_write("1");
+}
+
+static int newpid_thread_fn(void *arg)
+{
+       test_sysctl_child();
+       return 0;
+}
+
+static void test_sysctl_child2(void)
+{
+       int fd;
+
+       sysctl_fail_write("0");
+       fd = mfd_assert_new("kern_memfd_sysctl_1",
+                           mfd_def_size,
+                           MFD_CLOEXEC | MFD_ALLOW_SEALING);
+
+       mfd_assert_mode(fd, 0666);
+       mfd_assert_has_seals(fd, F_SEAL_EXEC);
+       mfd_fail_chmod(fd, 0777);
+       close(fd);
+}
+
+static int newpid_thread_fn2(void *arg)
+{
+       test_sysctl_child2();
+       return 0;
+}
+static pid_t spawn_newpid_thread(unsigned int flags, int (*fn)(void *))
+{
+       uint8_t *stack;
+       pid_t pid;
+
+       stack = malloc(STACK_SIZE);
+       if (!stack) {
+               printf("malloc(STACK_SIZE) failed: %m\n");
+               abort();
+       }
+
+       pid = clone(fn,
+                   stack + STACK_SIZE,
+                   SIGCHLD | flags,
+                   NULL);
+       if (pid < 0) {
+               printf("clone() failed: %m\n");
+               abort();
+       }
+
+       return pid;
+}
+
+static void join_newpid_thread(pid_t pid)
+{
+       waitpid(pid, NULL, 0);
+}
+
+/*
+ * Test sysctl
+ * A very basic sealing test to see whether setting/retrieving seals works.
+ */
+static void test_sysctl(void)
+{
+       int pid = spawn_newpid_thread(CLONE_NEWPID, newpid_thread_fn);
+
+       join_newpid_thread(pid);
+
+       printf("%s child ns\n", memfd_str);
+       sysctl_assert_write("1");
+
+       pid = spawn_newpid_thread(CLONE_NEWPID, newpid_thread_fn2);
+       join_newpid_thread(pid);
+}
+
 /*
  * Test sharing via dup()
  * Test that seals are shared between dupped FDs and they're all equal.
@@ -1173,13 +1387,15 @@ int main(int argc, char **argv)
 
        test_create();
        test_basic();
+       test_exec_seal();
+       test_exec_no_seal();
+       test_noexec_seal();
 
        test_seal_write();
        test_seal_future_write();
        test_seal_shrink();
        test_seal_grow();
        test_seal_resize();
-       test_seal_exec();
 
        test_share_dup("SHARE-DUP", "");
        test_share_mmap("SHARE-MMAP", "");
@@ -1195,6 +1411,8 @@ int main(int argc, char **argv)
        test_share_fork("SHARE-FORK", SHARED_FT_STR);
        join_idle_thread(pid);
 
+       test_sysctl();
+
        printf("memfd: DONE\n");
 
        return 0;