| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * may_decode_fh() refuses a file handle below a mount with locked children | |
| * to root in a user namespace. That has to hold while the mount is lazily | |
| * unmounted and its children, the locked ones too, are taken off it. | |
| */ | |
| #define _GNU_SOURCE | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <pthread.h> | |
| #include <sched.h> | |
| #include <stdatomic.h> | |
| #include <stdbool.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <unistd.h> | |
| #include <sys/mount.h> | |
| #include <sys/prctl.h> | |
| #include <sys/stat.h> | |
| #include <sys/syscall.h> | |
| #include <sys/wait.h> | |
| #include "../../kselftest_harness.h" | |
| #ifndef OPEN_TREE_CLONE | |
| #define OPEN_TREE_CLONE 1 | |
| #endif | |
| #ifndef OPEN_TREE_CLOEXEC | |
| #define OPEN_TREE_CLOEXEC O_CLOEXEC | |
| #endif | |
| #ifndef AT_RECURSIVE | |
| #define AT_RECURSIVE 0x8000 | |
| #endif | |
| #define DIR_LEN 64 | |
| #define PATH_LEN 128 | |
| #define ROUNDS 100 /* lazy umounts raced per test */ | |
| #define RACERS 3 /* threads in open_by_handle_at() */ | |
| #define EXTRA_MOUNTS 64 /* make umount_tree() hold mount_lock longer */ | |
| #define MAX_DELAY_US 3000 /* before the umount */ | |
| #define TAIL_US 2000 /* after it */ | |
| struct handle { | |
| struct file_handle fh; | |
| unsigned char buf[MAX_HANDLE_SZ]; | |
| }; | |
| /* exit codes of the child */ | |
| enum { | |
| CHILD_OK, | |
| CHILD_SETUP, | |
| CHILD_DECODED, /* decoded past a locked child */ | |
| CHILD_MOUNTED, /* not refused while mounted */ | |
| CHILD_UNMOUNTED, /* not refused once unmounted */ | |
| CHILD_ALLOWED, /* refused where nothing is locked */ | |
| CHILD_NOUSERNS, /* no user namespace to be had */ | |
| }; | |
| static int write_file(const char *path, const char *s) | |
| { | |
| ssize_t n = -1; | |
| int fd; | |
| fd = open(path, O_WRONLY | O_CLOEXEC); | |
| if (fd >= 0) { | |
| n = write(fd, s, strlen(s)); | |
| close(fd); | |
| } | |
| return n == (ssize_t)strlen(s) ? 0 : -1; | |
| } | |
| /* Become root in a new user namespace with a private mount namespace. */ | |
| static int enter_userns(void) | |
| { | |
| uid_t uid = getuid(); | |
| gid_t gid = getgid(); | |
| char map[32]; | |
| prctl(PR_SET_DUMPABLE, 1); | |
| /* EINVAL: no USER_NS, ENOSPC: user.max_user_namespaces is 0, EPERM: an LSM */ | |
| if (unshare(CLONE_NEWUSER | CLONE_NEWNS)) | |
| return errno == EINVAL || errno == ENOSPC || errno == EPERM ? | |
| CHILD_NOUSERNS : CHILD_SETUP; | |
| if (write_file("/proc/self/setgroups", "deny") && errno != ENOENT) | |
| return CHILD_SETUP; | |
| snprintf(map, sizeof(map), "0 %d 1", uid); | |
| if (write_file("/proc/self/uid_map", map)) | |
| return CHILD_SETUP; | |
| snprintf(map, sizeof(map), "0 %d 1", gid); | |
| if (write_file("/proc/self/gid_map", map)) | |
| return CHILD_SETUP; | |
| if (setgid(0) || setuid(0)) | |
| return CHILD_SETUP; | |
| if (mount("", "/", NULL, MS_REC | MS_PRIVATE, NULL)) | |
| return CHILD_SETUP; | |
| return CHILD_OK; | |
| } | |
| static int get_handle(const char *path, struct handle *h) | |
| { | |
| int mntid; | |
| h->fh.handle_bytes = MAX_HANDLE_SZ; | |
| return name_to_handle_at(AT_FDCWD, path, &h->fh, &mntid, 0); | |
| } | |
| static int decode(int dfd, struct handle *h) | |
| { | |
| return open_by_handle_at(dfd, &h->fh, O_RDONLY | O_DIRECTORY | O_CLOEXEC); | |
| } | |
| struct race { | |
| int dfd; | |
| struct handle *h; | |
| atomic_int go; | |
| atomic_int stop; | |
| atomic_int won; /* the first decoded descriptor */ | |
| }; | |
| static void *racer(void *arg) | |
| { | |
| struct race *r = arg; | |
| while (!atomic_load(&r->go)) | |
| ; | |
| while (!atomic_load(&r->stop)) { | |
| int none = -1; | |
| int fd; | |
| fd = decode(r->dfd, r->h); | |
| if (fd < 0) | |
| continue; | |
| if (!atomic_compare_exchange_strong(&r->won, &none, fd)) | |
| close(fd); | |
| } | |
| return NULL; | |
| } | |
| /* stop the @n racers started so far and wait for them, they spin on @r */ | |
| static void stop_racers(struct race *r, pthread_t *th, int n) | |
| { | |
| int i; | |
| atomic_store(&r->stop, 1); | |
| atomic_store(&r->go, 1); /* one still waiting for the start sees stop next */ | |
| for (i = 0; i < n; i++) | |
| pthread_join(th[i], NULL); | |
| } | |
| /* | |
| * Bind @h recursively at @w, or take a detached copy of it, and race | |
| * open_by_handle_at() of @inner against the lazy umount. The decoded | |
| * descriptor, if there was one, is left in @won. | |
| */ | |
| static int race_round(const char *h, const char *w, struct handle *inner, | |
| bool dissolve, int *won) | |
| { | |
| struct race r = { .h = inner, .won = -1 }; | |
| pthread_t th[RACERS]; | |
| int treefd = -1, fd, i; | |
| if (dissolve) { | |
| treefd = syscall(__NR_open_tree, AT_FDCWD, h, | |
| OPEN_TREE_CLONE | AT_RECURSIVE | OPEN_TREE_CLOEXEC); | |
| if (treefd < 0) | |
| return CHILD_SETUP; | |
| /* an ordinary descriptor on the copy, treefd's close dissolves it */ | |
| r.dfd = openat(treefd, ".", O_RDONLY | O_DIRECTORY | O_CLOEXEC); | |
| } else { | |
| if (mount(h, w, NULL, MS_BIND | MS_REC, NULL)) | |
| return CHILD_SETUP; | |
| r.dfd = open(w, O_RDONLY | O_DIRECTORY | O_CLOEXEC); | |
| } | |
| if (r.dfd < 0) | |
| return CHILD_SETUP; | |
| fd = decode(r.dfd, inner); | |
| if (fd >= 0 || errno != EPERM) { | |
| if (fd >= 0) | |
| close(fd); | |
| return CHILD_MOUNTED; | |
| } | |
| for (i = 0; i < RACERS; i++) { | |
| if (pthread_create(&th[i], NULL, racer, &r)) { | |
| stop_racers(&r, th, i); | |
| return CHILD_SETUP; | |
| } | |
| } | |
| atomic_store(&r.go, 1); | |
| usleep(rand() % MAX_DELAY_US); | |
| if (dissolve) | |
| close(treefd); | |
| else if (umount2(w, MNT_DETACH)) { | |
| stop_racers(&r, th, RACERS); | |
| return CHILD_SETUP; | |
| } | |
| usleep(TAIL_US); | |
| stop_racers(&r, th, RACERS); | |
| fd = decode(r.dfd, inner); | |
| if (fd >= 0) { | |
| close(fd); | |
| return CHILD_UNMOUNTED; | |
| } | |
| close(r.dfd); | |
| *won = atomic_load(&r.won); | |
| return CHILD_OK; | |
| } | |
| static int race_child(const char *h, const char *w, struct handle *inner, | |
| bool dissolve) | |
| { | |
| int ret, won, i; | |
| srand(getpid()); | |
| ret = enter_userns(); | |
| if (ret) | |
| return ret; | |
| for (i = 0; i < ROUNDS; i++) { | |
| ret = race_round(h, w, inner, dissolve, &won); | |
| if (ret) | |
| return ret; | |
| if (won >= 0) | |
| return CHILD_DECODED; | |
| } | |
| return CHILD_OK; | |
| } | |
| /* a bind without locked children decodes while mounted and not after */ | |
| static int allowed_child(const char *plain, const char *w, struct handle *h) | |
| { | |
| int dfd, fd, ret; | |
| ret = enter_userns(); | |
| if (ret) | |
| return ret; | |
| if (mount(plain, w, NULL, MS_BIND | MS_REC, NULL)) | |
| return CHILD_SETUP; | |
| dfd = open(w, O_RDONLY | O_DIRECTORY | O_CLOEXEC); | |
| if (dfd < 0) | |
| return CHILD_SETUP; | |
| fd = decode(dfd, h); | |
| if (fd < 0) | |
| return CHILD_ALLOWED; | |
| close(fd); | |
| if (umount2(w, MNT_DETACH)) | |
| return CHILD_SETUP; | |
| fd = decode(dfd, h); | |
| if (fd >= 0) { | |
| close(fd); | |
| return CHILD_UNMOUNTED; | |
| } | |
| return errno == EPERM ? CHILD_OK : CHILD_UNMOUNTED; | |
| } | |
| FIXTURE(locked_handle) { | |
| char base[DIR_LEN]; | |
| char h[PATH_LEN]; /* the tree with the covered directory */ | |
| char plain[PATH_LEN]; /* a tree with no mount in it */ | |
| char w[PATH_LEN]; /* where the child binds either */ | |
| struct handle inner; /* h/top/secret/inner, covered */ | |
| struct handle uncovered; /* plain/inner */ | |
| }; | |
| FIXTURE_SETUP(locked_handle) | |
| { | |
| char p[PATH_LEN], e[PATH_LEN]; | |
| int i; | |
| if (geteuid()) | |
| SKIP(return, "test requires root"); | |
| snprintf(self->base, sizeof(self->base), "/tmp/locked_handle.XXXXXX"); | |
| ASSERT_NE(mkdtemp(self->base), NULL); | |
| ASSERT_EQ(unshare(CLONE_NEWNS), 0); | |
| ASSERT_EQ(mount("", "/", NULL, MS_REC | MS_PRIVATE, NULL), 0); | |
| ASSERT_EQ(mount("tmpfs", self->base, "tmpfs", 0, NULL), 0); | |
| snprintf(self->h, sizeof(self->h), "%s/h", self->base); | |
| snprintf(self->plain, sizeof(self->plain), "%s/plain", self->base); | |
| snprintf(self->w, sizeof(self->w), "%s/w", self->base); | |
| ASSERT_EQ(mkdir(self->h, 0755), 0); | |
| ASSERT_EQ(mkdir(self->plain, 0755), 0); | |
| ASSERT_EQ(mkdir(self->w, 0755), 0); | |
| snprintf(p, sizeof(p), "%s/plain/inner", self->base); | |
| ASSERT_EQ(mkdir(p, 0755), 0); | |
| ASSERT_EQ(get_handle(p, &self->uncovered), 0); | |
| /* the handle is for this filesystem */ | |
| ASSERT_EQ(mount("tmpfs", self->h, "tmpfs", 0, NULL), 0); | |
| snprintf(p, sizeof(p), "%s/h/top", self->base); | |
| ASSERT_EQ(mkdir(p, 0755), 0); | |
| snprintf(p, sizeof(p), "%s/h/top/secret", self->base); | |
| ASSERT_EQ(mkdir(p, 0755), 0); | |
| snprintf(p, sizeof(p), "%s/h/top/secret/inner", self->base); | |
| ASSERT_EQ(mkdir(p, 0755), 0); | |
| ASSERT_EQ(get_handle(p, &self->inner), 0); | |
| snprintf(e, sizeof(e), "%s/h/empty", self->base); | |
| ASSERT_EQ(mkdir(e, 0755), 0); | |
| /* cover it, and some more so the umount takes longer */ | |
| snprintf(p, sizeof(p), "%s/h/top/secret", self->base); | |
| ASSERT_EQ(mount("tmpfs", p, "tmpfs", 0, NULL), 0); | |
| for (i = 0; i < EXTRA_MOUNTS; i++) { | |
| snprintf(p, sizeof(p), "%s/h/c%d", self->base, i); | |
| ASSERT_EQ(mkdir(p, 0755), 0); | |
| ASSERT_EQ(mount(e, p, NULL, MS_BIND, NULL), 0); | |
| } | |
| } | |
| FIXTURE_TEARDOWN(locked_handle) | |
| { | |
| umount2(self->base, MNT_DETACH); | |
| rmdir(self->base); | |
| } | |
| static int wait_child(pid_t pid) | |
| { | |
| int status; | |
| if (waitpid(pid, &status, 0) != pid || !WIFEXITED(status)) | |
| return -1; | |
| return WEXITSTATUS(status); | |
| } | |
| TEST_F(locked_handle, lazy_umount) | |
| { | |
| pid_t pid; | |
| int ret; | |
| pid = fork(); | |
| ASSERT_GE(pid, 0); | |
| if (pid == 0) | |
| _exit(race_child(self->h, self->w, &self->inner, false)); | |
| ret = wait_child(pid); | |
| TH_LOG("child exit code %d", ret); | |
| if (ret == CHILD_NOUSERNS) | |
| SKIP(return, "no user namespaces"); | |
| EXPECT_EQ(ret, CHILD_OK); | |
| } | |
| TEST_F(locked_handle, dissolve) | |
| { | |
| pid_t pid; | |
| int ret; | |
| pid = fork(); | |
| ASSERT_GE(pid, 0); | |
| if (pid == 0) | |
| _exit(race_child(self->h, self->w, &self->inner, true)); | |
| ret = wait_child(pid); | |
| TH_LOG("child exit code %d", ret); | |
| if (ret == CHILD_NOUSERNS) | |
| SKIP(return, "no user namespaces"); | |
| EXPECT_EQ(ret, CHILD_OK); | |
| } | |
| TEST_F(locked_handle, allowed_use) | |
| { | |
| pid_t pid; | |
| int ret; | |
| pid = fork(); | |
| ASSERT_GE(pid, 0); | |
| if (pid == 0) | |
| _exit(allowed_child(self->plain, self->w, &self->uncovered)); | |
| ret = wait_child(pid); | |
| TH_LOG("child exit code %d", ret); | |
| if (ret == CHILD_NOUSERNS) | |
| SKIP(return, "no user namespaces"); | |
| EXPECT_EQ(ret, CHILD_OK); | |
| } | |
| TEST_HARNESS_MAIN |