1 // SPDX-License-Identifier: GPL-2.0 2 #define _GNU_SOURCE 3 #include <sched.h> 4 #include <stdio.h> 5 #include <errno.h> 6 #include <string.h> 7 #include <sys/types.h> 8 #include <sys/mount.h> 9 #include <sys/wait.h> 10 #include <sys/vfs.h> 11 #include <sys/statvfs.h> 12 #include <stdlib.h> 13 #include <unistd.h> 14 #include <fcntl.h> 15 #include <grp.h> 16 #include <stdbool.h> 17 #include <stdarg.h> 18 19 #ifndef CLONE_NEWNS 20 # define CLONE_NEWNS 0x00020000 21 #endif 22 #ifndef CLONE_NEWUTS 23 # define CLONE_NEWUTS 0x04000000 24 #endif 25 #ifndef CLONE_NEWIPC 26 # define CLONE_NEWIPC 0x08000000 27 #endif 28 #ifndef CLONE_NEWNET 29 # define CLONE_NEWNET 0x40000000 30 #endif 31 #ifndef CLONE_NEWUSER 32 # define CLONE_NEWUSER 0x10000000 33 #endif 34 #ifndef CLONE_NEWPID 35 # define CLONE_NEWPID 0x20000000 36 #endif 37 38 #ifndef MS_REC 39 # define MS_REC 16384 40 #endif 41 #ifndef MS_RELATIME 42 # define MS_RELATIME (1 << 21) 43 #endif 44 #ifndef MS_STRICTATIME 45 # define MS_STRICTATIME (1 << 24) 46 #endif 47 48 static void die(char *fmt, ...) 49 { 50 va_list ap; 51 va_start(ap, fmt); 52 vfprintf(stderr, fmt, ap); 53 va_end(ap); 54 exit(EXIT_FAILURE); 55 } 56 57 static void vmaybe_write_file(bool enoent_ok, char *filename, char *fmt, va_list ap) 58 { 59 char buf[4096]; 60 int fd; 61 ssize_t written; 62 int buf_len; 63 64 buf_len = vsnprintf(buf, sizeof(buf), fmt, ap); 65 if (buf_len < 0) { 66 die("vsnprintf failed: %s\n", 67 strerror(errno)); 68 } 69 if (buf_len >= sizeof(buf)) { 70 die("vsnprintf output truncated\n"); 71 } 72 73 fd = open(filename, O_WRONLY); 74 if (fd < 0) { 75 if ((errno == ENOENT) && enoent_ok) 76 return; 77 die("open of %s failed: %s\n", 78 filename, strerror(errno)); 79 } 80 written = write(fd, buf, buf_len); 81 if (written != buf_len) { 82 if (written >= 0) { 83 die("short write to %s\n", filename); 84 } else { 85 die("write to %s failed: %s\n", 86 filename, strerror(errno)); 87 } 88 } 89 if (close(fd) != 0) { 90 die("close of %s failed: %s\n", 91 filename, strerror(errno)); 92 } 93 } 94 95 static void maybe_write_file(char *filename, char *fmt, ...) 96 { 97 va_list ap; 98 99 va_start(ap, fmt); 100 vmaybe_write_file(true, filename, fmt, ap); 101 va_end(ap); 102 103 } 104 105 static void write_file(char *filename, char *fmt, ...) 106 { 107 va_list ap; 108 109 va_start(ap, fmt); 110 vmaybe_write_file(false, filename, fmt, ap); 111 va_end(ap); 112 113 } 114 115 static int read_mnt_flags(const char *path) 116 { 117 int ret; 118 struct statvfs stat; 119 int mnt_flags; 120 121 ret = statvfs(path, &stat); 122 if (ret != 0) { 123 die("statvfs of %s failed: %s\n", 124 path, strerror(errno)); 125 } 126 if (stat.f_flag & ~(ST_RDONLY | ST_NOSUID | ST_NODEV | \ 127 ST_NOEXEC | ST_NOATIME | ST_NODIRATIME | ST_RELATIME | \ 128 ST_SYNCHRONOUS | ST_MANDLOCK)) { 129 die("Unrecognized mount flags\n"); 130 } 131 mnt_flags = 0; 132 if (stat.f_flag & ST_RDONLY) 133 mnt_flags |= MS_RDONLY; 134 if (stat.f_flag & ST_NOSUID) 135 mnt_flags |= MS_NOSUID; 136 if (stat.f_flag & ST_NODEV) 137 mnt_flags |= MS_NODEV; 138 if (stat.f_flag & ST_NOEXEC) 139 mnt_flags |= MS_NOEXEC; 140 if (stat.f_flag & ST_NOATIME) 141 mnt_flags |= MS_NOATIME; 142 if (stat.f_flag & ST_NODIRATIME) 143 mnt_flags |= MS_NODIRATIME; 144 if (stat.f_flag & ST_RELATIME) 145 mnt_flags |= MS_RELATIME; 146 if (stat.f_flag & ST_SYNCHRONOUS) 147 mnt_flags |= MS_SYNCHRONOUS; 148 if (stat.f_flag & ST_MANDLOCK) 149 mnt_flags |= ST_MANDLOCK; 150 151 return mnt_flags; 152 } 153 154 static void create_and_enter_userns(void) 155 { 156 uid_t uid; 157 gid_t gid; 158 159 uid = getuid(); 160 gid = getgid(); 161 162 if (unshare(CLONE_NEWUSER) !=0) { 163 die("unshare(CLONE_NEWUSER) failed: %s\n", 164 strerror(errno)); 165 } 166 167 maybe_write_file("/proc/self/setgroups", "deny"); 168 write_file("/proc/self/uid_map", "0 %d 1", uid); 169 write_file("/proc/self/gid_map", "0 %d 1", gid); 170 171 if (setgid(0) != 0) { 172 die ("setgid(0) failed %s\n", 173 strerror(errno)); 174 } 175 if (setuid(0) != 0) { 176 die("setuid(0) failed %s\n", 177 strerror(errno)); 178 } 179 } 180 181 static 182 bool test_unpriv_remount(const char *fstype, const char *mount_options, 183 int mount_flags, int remount_flags, int invalid_flags) 184 { 185 pid_t child; 186 187 child = fork(); 188 if (child == -1) { 189 die("fork failed: %s\n", 190 strerror(errno)); 191 } 192 if (child != 0) { /* parent */ 193 pid_t pid; 194 int status; 195 pid = waitpid(child, &status, 0); 196 if (pid == -1) { 197 die("waitpid failed: %s\n", 198 strerror(errno)); 199 } 200 if (pid != child) { 201 die("waited for %d got %d\n", 202 child, pid); 203 } 204 if (!WIFEXITED(status)) { 205 die("child did not terminate cleanly\n"); 206 } 207 return WEXITSTATUS(status) == EXIT_SUCCESS; 208 } 209 210 create_and_enter_userns(); 211 if (unshare(CLONE_NEWNS) != 0) { 212 die("unshare(CLONE_NEWNS) failed: %s\n", 213 strerror(errno)); 214 } 215 216 if (mount("testing", "/tmp", fstype, mount_flags, mount_options) != 0) { 217 die("mount of %s with options '%s' on /tmp failed: %s\n", 218 fstype, 219 mount_options? mount_options : "", 220 strerror(errno)); 221 } 222 223 create_and_enter_userns(); 224 225 if (unshare(CLONE_NEWNS) != 0) { 226 die("unshare(CLONE_NEWNS) failed: %s\n", 227 strerror(errno)); 228 } 229 230 if (mount("/tmp", "/tmp", "none", 231 MS_REMOUNT | MS_BIND | remount_flags, NULL) != 0) { 232 /* system("cat /proc/self/mounts"); */ 233 die("remount of /tmp failed: %s\n", 234 strerror(errno)); 235 } 236 237 if (mount("/tmp", "/tmp", "none", 238 MS_REMOUNT | MS_BIND | invalid_flags, NULL) == 0) { 239 /* system("cat /proc/self/mounts"); */ 240 die("remount of /tmp with invalid flags " 241 "succeeded unexpectedly\n"); 242 } 243 exit(EXIT_SUCCESS); 244 } 245 246 static bool test_unpriv_remount_simple(int mount_flags) 247 { 248 return test_unpriv_remount("ramfs", NULL, mount_flags, mount_flags, 0); 249 } 250 251 static bool test_unpriv_remount_atime(int mount_flags, int invalid_flags) 252 { 253 return test_unpriv_remount("ramfs", NULL, mount_flags, mount_flags, 254 invalid_flags); 255 } 256 257 static bool test_priv_mount_unpriv_remount(void) 258 { 259 pid_t child; 260 int ret; 261 const char *orig_path = "/dev"; 262 const char *dest_path = "/tmp"; 263 int orig_mnt_flags, remount_mnt_flags; 264 265 child = fork(); 266 if (child == -1) { 267 die("fork failed: %s\n", 268 strerror(errno)); 269 } 270 if (child != 0) { /* parent */ 271 pid_t pid; 272 int status; 273 pid = waitpid(child, &status, 0); 274 if (pid == -1) { 275 die("waitpid failed: %s\n", 276 strerror(errno)); 277 } 278 if (pid != child) { 279 die("waited for %d got %d\n", 280 child, pid); 281 } 282 if (!WIFEXITED(status)) { 283 die("child did not terminate cleanly\n"); 284 } 285 return WEXITSTATUS(status) == EXIT_SUCCESS; 286 } 287 288 orig_mnt_flags = read_mnt_flags(orig_path); 289 290 create_and_enter_userns(); 291 ret = unshare(CLONE_NEWNS); 292 if (ret != 0) { 293 die("unshare(CLONE_NEWNS) failed: %s\n", 294 strerror(errno)); 295 } 296 297 ret = mount(orig_path, dest_path, "bind", MS_BIND | MS_REC, NULL); 298 if (ret != 0) { 299 die("recursive bind mount of %s onto %s failed: %s\n", 300 orig_path, dest_path, strerror(errno)); 301 } 302 303 ret = mount(dest_path, dest_path, "none", 304 MS_REMOUNT | MS_BIND | orig_mnt_flags , NULL); 305 if (ret != 0) { 306 /* system("cat /proc/self/mounts"); */ 307 die("remount of /tmp failed: %s\n", 308 strerror(errno)); 309 } 310 311 remount_mnt_flags = read_mnt_flags(dest_path); 312 if (orig_mnt_flags != remount_mnt_flags) { 313 die("Mount flags unexpectedly changed during remount of %s originally mounted on %s\n", 314 dest_path, orig_path); 315 } 316 exit(EXIT_SUCCESS); 317 } 318 319 int main(int argc, char **argv) 320 { 321 if (!test_unpriv_remount_simple(MS_RDONLY)) { 322 die("MS_RDONLY malfunctions\n"); 323 } 324 if (!test_unpriv_remount("devpts", "newinstance", MS_NODEV, MS_NODEV, 0)) { 325 die("MS_NODEV malfunctions\n"); 326 } 327 if (!test_unpriv_remount_simple(MS_NOSUID)) { 328 die("MS_NOSUID malfunctions\n"); 329 } 330 if (!test_unpriv_remount_simple(MS_NOEXEC)) { 331 die("MS_NOEXEC malfunctions\n"); 332 } 333 if (!test_unpriv_remount_atime(MS_RELATIME, 334 MS_NOATIME)) 335 { 336 die("MS_RELATIME malfunctions\n"); 337 } 338 if (!test_unpriv_remount_atime(MS_STRICTATIME, 339 MS_NOATIME)) 340 { 341 die("MS_STRICTATIME malfunctions\n"); 342 } 343 if (!test_unpriv_remount_atime(MS_NOATIME, 344 MS_STRICTATIME)) 345 { 346 die("MS_NOATIME malfunctions\n"); 347 } 348 if (!test_unpriv_remount_atime(MS_RELATIME|MS_NODIRATIME, 349 MS_NOATIME)) 350 { 351 die("MS_RELATIME|MS_NODIRATIME malfunctions\n"); 352 } 353 if (!test_unpriv_remount_atime(MS_STRICTATIME|MS_NODIRATIME, 354 MS_NOATIME)) 355 { 356 die("MS_STRICTATIME|MS_NODIRATIME malfunctions\n"); 357 } 358 if (!test_unpriv_remount_atime(MS_NOATIME|MS_NODIRATIME, 359 MS_STRICTATIME)) 360 { 361 die("MS_NOATIME|MS_DIRATIME malfunctions\n"); 362 } 363 if (!test_unpriv_remount("ramfs", NULL, MS_STRICTATIME, 0, MS_NOATIME)) 364 { 365 die("Default atime malfunctions\n"); 366 } 367 if (!test_priv_mount_unpriv_remount()) { 368 die("Mount flags unexpectedly changed after remount\n"); 369 } 370 return EXIT_SUCCESS; 371 } 372