1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corporation, 2021 4 * 5 * Author: Mike Rapoport <rppt@linux.ibm.com> 6 */ 7 8 #define _GNU_SOURCE 9 #include <sys/uio.h> 10 #include <sys/mman.h> 11 #include <sys/wait.h> 12 #include <sys/types.h> 13 #include <sys/ptrace.h> 14 #include <sys/syscall.h> 15 #include <sys/resource.h> 16 #include <sys/capability.h> 17 18 #include <stdlib.h> 19 #include <string.h> 20 #include <unistd.h> 21 #include <errno.h> 22 #include <stdio.h> 23 24 #include "../kselftest.h" 25 26 #define fail(fmt, ...) ksft_test_result_fail(fmt, ##__VA_ARGS__) 27 #define pass(fmt, ...) ksft_test_result_pass(fmt, ##__VA_ARGS__) 28 #define skip(fmt, ...) ksft_test_result_skip(fmt, ##__VA_ARGS__) 29 30 #ifdef __NR_memfd_secret 31 32 #define PATTERN 0x55 33 34 static const int prot = PROT_READ | PROT_WRITE; 35 static const int mode = MAP_SHARED; 36 37 static unsigned long page_size; 38 static unsigned long mlock_limit_cur; 39 static unsigned long mlock_limit_max; 40 41 static int memfd_secret(unsigned int flags) 42 { 43 return syscall(__NR_memfd_secret, flags); 44 } 45 46 static void test_file_apis(int fd) 47 { 48 char buf[64]; 49 50 if ((read(fd, buf, sizeof(buf)) >= 0) || 51 (write(fd, buf, sizeof(buf)) >= 0) || 52 (pread(fd, buf, sizeof(buf), 0) >= 0) || 53 (pwrite(fd, buf, sizeof(buf), 0) >= 0)) 54 fail("unexpected file IO\n"); 55 else 56 pass("file IO is blocked as expected\n"); 57 } 58 59 static void test_mlock_limit(int fd) 60 { 61 size_t len; 62 char *mem; 63 64 len = mlock_limit_cur; 65 mem = mmap(NULL, len, prot, mode, fd, 0); 66 if (mem == MAP_FAILED) { 67 fail("unable to mmap secret memory\n"); 68 return; 69 } 70 munmap(mem, len); 71 72 len = mlock_limit_max * 2; 73 mem = mmap(NULL, len, prot, mode, fd, 0); 74 if (mem != MAP_FAILED) { 75 fail("unexpected mlock limit violation\n"); 76 munmap(mem, len); 77 return; 78 } 79 80 pass("mlock limit is respected\n"); 81 } 82 83 static void try_process_vm_read(int fd, int pipefd[2]) 84 { 85 struct iovec liov, riov; 86 char buf[64]; 87 char *mem; 88 89 if (read(pipefd[0], &mem, sizeof(mem)) < 0) { 90 fail("pipe write: %s\n", strerror(errno)); 91 exit(KSFT_FAIL); 92 } 93 94 liov.iov_len = riov.iov_len = sizeof(buf); 95 liov.iov_base = buf; 96 riov.iov_base = mem; 97 98 if (process_vm_readv(getppid(), &liov, 1, &riov, 1, 0) < 0) { 99 if (errno == ENOSYS) 100 exit(KSFT_SKIP); 101 exit(KSFT_PASS); 102 } 103 104 exit(KSFT_FAIL); 105 } 106 107 static void try_ptrace(int fd, int pipefd[2]) 108 { 109 pid_t ppid = getppid(); 110 int status; 111 char *mem; 112 long ret; 113 114 if (read(pipefd[0], &mem, sizeof(mem)) < 0) { 115 perror("pipe write"); 116 exit(KSFT_FAIL); 117 } 118 119 ret = ptrace(PTRACE_ATTACH, ppid, 0, 0); 120 if (ret) { 121 perror("ptrace_attach"); 122 exit(KSFT_FAIL); 123 } 124 125 ret = waitpid(ppid, &status, WUNTRACED); 126 if ((ret != ppid) || !(WIFSTOPPED(status))) { 127 fprintf(stderr, "weird waitppid result %ld stat %x\n", 128 ret, status); 129 exit(KSFT_FAIL); 130 } 131 132 if (ptrace(PTRACE_PEEKDATA, ppid, mem, 0)) 133 exit(KSFT_PASS); 134 135 exit(KSFT_FAIL); 136 } 137 138 static void check_child_status(pid_t pid, const char *name) 139 { 140 int status; 141 142 waitpid(pid, &status, 0); 143 144 if (WIFEXITED(status) && WEXITSTATUS(status) == KSFT_SKIP) { 145 skip("%s is not supported\n", name); 146 return; 147 } 148 149 if ((WIFEXITED(status) && WEXITSTATUS(status) == KSFT_PASS) || 150 WIFSIGNALED(status)) { 151 pass("%s is blocked as expected\n", name); 152 return; 153 } 154 155 fail("%s: unexpected memory access\n", name); 156 } 157 158 static void test_remote_access(int fd, const char *name, 159 void (*func)(int fd, int pipefd[2])) 160 { 161 int pipefd[2]; 162 pid_t pid; 163 char *mem; 164 165 if (pipe(pipefd)) { 166 fail("pipe failed: %s\n", strerror(errno)); 167 return; 168 } 169 170 pid = fork(); 171 if (pid < 0) { 172 fail("fork failed: %s\n", strerror(errno)); 173 return; 174 } 175 176 if (pid == 0) { 177 func(fd, pipefd); 178 return; 179 } 180 181 mem = mmap(NULL, page_size, prot, mode, fd, 0); 182 if (mem == MAP_FAILED) { 183 fail("Unable to mmap secret memory\n"); 184 return; 185 } 186 187 ftruncate(fd, page_size); 188 memset(mem, PATTERN, page_size); 189 190 if (write(pipefd[1], &mem, sizeof(mem)) < 0) { 191 fail("pipe write: %s\n", strerror(errno)); 192 return; 193 } 194 195 check_child_status(pid, name); 196 } 197 198 static void test_process_vm_read(int fd) 199 { 200 test_remote_access(fd, "process_vm_read", try_process_vm_read); 201 } 202 203 static void test_ptrace(int fd) 204 { 205 test_remote_access(fd, "ptrace", try_ptrace); 206 } 207 208 static int set_cap_limits(rlim_t max) 209 { 210 struct rlimit new; 211 cap_t cap = cap_init(); 212 213 new.rlim_cur = max; 214 new.rlim_max = max; 215 if (setrlimit(RLIMIT_MEMLOCK, &new)) { 216 perror("setrlimit() returns error"); 217 return -1; 218 } 219 220 /* drop capabilities including CAP_IPC_LOCK */ 221 if (cap_set_proc(cap)) { 222 perror("cap_set_proc() returns error"); 223 return -2; 224 } 225 226 return 0; 227 } 228 229 static void prepare(void) 230 { 231 struct rlimit rlim; 232 233 page_size = sysconf(_SC_PAGE_SIZE); 234 if (!page_size) 235 ksft_exit_fail_msg("Failed to get page size %s\n", 236 strerror(errno)); 237 238 if (getrlimit(RLIMIT_MEMLOCK, &rlim)) 239 ksft_exit_fail_msg("Unable to detect mlock limit: %s\n", 240 strerror(errno)); 241 242 mlock_limit_cur = rlim.rlim_cur; 243 mlock_limit_max = rlim.rlim_max; 244 245 printf("page_size: %ld, mlock.soft: %ld, mlock.hard: %ld\n", 246 page_size, mlock_limit_cur, mlock_limit_max); 247 248 if (page_size > mlock_limit_cur) 249 mlock_limit_cur = page_size; 250 if (page_size > mlock_limit_max) 251 mlock_limit_max = page_size; 252 253 if (set_cap_limits(mlock_limit_max)) 254 ksft_exit_fail_msg("Unable to set mlock limit: %s\n", 255 strerror(errno)); 256 } 257 258 #define NUM_TESTS 4 259 260 int main(int argc, char *argv[]) 261 { 262 int fd; 263 264 prepare(); 265 266 ksft_print_header(); 267 ksft_set_plan(NUM_TESTS); 268 269 fd = memfd_secret(0); 270 if (fd < 0) { 271 if (errno == ENOSYS) 272 ksft_exit_skip("memfd_secret is not supported\n"); 273 else 274 ksft_exit_fail_msg("memfd_secret failed: %s\n", 275 strerror(errno)); 276 } 277 278 test_mlock_limit(fd); 279 test_file_apis(fd); 280 test_process_vm_read(fd); 281 test_ptrace(fd); 282 283 close(fd); 284 285 ksft_finished(); 286 } 287 288 #else /* __NR_memfd_secret */ 289 290 int main(int argc, char *argv[]) 291 { 292 printf("skip: skipping memfd_secret test (missing __NR_memfd_secret)\n"); 293 return KSFT_SKIP; 294 } 295 296 #endif /* __NR_memfd_secret */ 297