seccomp/user-trap.c

   1 #include <signal.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <unistd.h>
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <string.h>
   8 #include <stddef.h>
   9 #include <sys/sysmacros.h>
  10 #include <sys/types.h>
  11 #include <sys/wait.h>
  12 #include <sys/socket.h>
  13 #include <sys/stat.h>
  14 #include <sys/mman.h>
  15 #include <sys/syscall.h>
  16 #include <sys/user.h>
  17 #include <sys/ioctl.h>
  18 #include <sys/ptrace.h>
  19 #include <sys/mount.h>
  20 #include <linux/limits.h>
  21 #include <linux/filter.h>
  22 #include <linux/seccomp.h>
  23
  24 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
  25
  26 static int seccomp(unsigned int op, unsigned int flags, void *args)
  27 {
  28         errno = 0;
  29         return syscall(__NR_seccomp, op, flags, args);
  30 }
  31
  32 static int send_fd(int sock, int fd)
  33 {
  34         struct msghdr msg = {};
  35         struct cmsghdr *cmsg;
  36         int *fd_ptr;
  37         char buf[CMSG_SPACE(sizeof(int))] = {0}, c = 'c';
  38         struct iovec io = {
  39                 .iov_base = &c,
  40                 .iov_len = 1,
  41         };
  42
  43         msg.msg_iov = &io;
  44         msg.msg_iovlen = 1;
  45         msg.msg_control = buf;
  46         msg.msg_controllen = sizeof(buf);
  47         cmsg = CMSG_FIRSTHDR(&msg);
  48         cmsg->cmsg_level = SOL_SOCKET;
  49         cmsg->cmsg_type = SCM_RIGHTS;
  50         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
  51         fd_ptr = (int *)CMSG_DATA(cmsg);
  52         *fd_ptr = fd;
  53         msg.msg_controllen = cmsg->cmsg_len;
  54
  55         if (sendmsg(sock, &msg, 0) < 0) {
  56                 perror("sendmsg");
  57                 return -1;
  58         }
  59
  60         return 0;
  61 }
  62
  63 static int recv_fd(int sock)
  64 {
  65         struct msghdr msg = {};
  66         struct cmsghdr *cmsg;
  67         int *fd_ptr;
  68         char buf[CMSG_SPACE(sizeof(int))] = {0}, c = 'c';
  69         struct iovec io = {
  70                 .iov_base = &c,
  71                 .iov_len = 1,
  72         };
  73
  74         msg.msg_iov = &io;
  75         msg.msg_iovlen = 1;
  76         msg.msg_control = buf;
  77         msg.msg_controllen = sizeof(buf);
  78
  79         if (recvmsg(sock, &msg, 0) < 0) {
  80                 perror("recvmsg");
  81                 return -1;
  82         }
  83
  84         cmsg = CMSG_FIRSTHDR(&msg);
  85         fd_ptr = (int *)CMSG_DATA(cmsg);
  86
  87         return *fd_ptr;
  88 }
  89
  90 static int user_trap_syscall(int nr, unsigned int flags)
  91 {
  92         struct sock_filter filter[] = {
  93                 BPF_STMT(BPF_LD+BPF_W+BPF_ABS,
  94                         offsetof(struct seccomp_data, nr)),
  95                 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, nr, 0, 1),
  96                 BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_USER_NOTIF),
  97                 BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW),
  98         };
  99
 100         struct sock_fprog prog = {
 101                 .len = (unsigned short)ARRAY_SIZE(filter),
 102                 .filter = filter,
 103         };
 104
 105         return seccomp(SECCOMP_SET_MODE_FILTER, flags, &prog);
 106 }
 107
 108 static int handle_req(struct seccomp_notif *req,
 109                       struct seccomp_notif_resp *resp, int listener)
 110 {
 111         char path[PATH_MAX], source[PATH_MAX], target[PATH_MAX];
 112         int ret = -1, mem;
 113
 114         resp->id = req->id;
 115         resp->error = -EPERM;
 116         resp->val = 0;
 117
 118         if (req->data.nr != __NR_mount) {
 119                 fprintf(stderr, "huh? trapped something besides mount? %d\n", req->data.nr);
 120                 return -1;
 121         }
 122
 123         /* Only allow bind mounts. */
 124         if (!(req->data.args[3] & MS_BIND))
 125                 return 0;
 126
 127         /*
 128          * Ok, let's read the task's memory to see where they wanted their
 129          * mount to go.
 130          */
 131         snprintf(path, sizeof(path), "/proc/%d/mem", req->pid);
 132         mem = open(path, O_RDONLY);
 133         if (mem < 0) {
 134                 perror("open mem");
 135                 return -1;
 136         }
 137
 138         /*
 139          * Now we avoid a TOCTOU: we referred to a pid by its pid, but since
 140          * the pid that made the syscall may have died, we need to confirm that
 141          * the pid is still valid after we open its /proc/pid/mem file. We can
 142          * ask the listener fd this as follows.
 143          *
 144          * Note that this check should occur *after* any task-specific
 145          * resources are opened, to make sure that the task has not died and
 146          * we're not wrongly reading someone else's state in order to make
 147          * decisions.
 148          */
 149         if (ioctl(listener, SECCOMP_IOCTL_NOTIF_ID_VALID, &req->id) < 0) {
 150                 fprintf(stderr, "task died before we could map its memory\n");
 151                 goto out;
 152         }
 153
 154         /*
 155          * Phew, we've got the right /proc/pid/mem. Now we can read it. Note
 156          * that to avoid another TOCTOU, we should read all of the pointer args
 157          * before we decide to allow the syscall.
 158          */
 159         if (lseek(mem, req->data.args[0], SEEK_SET) < 0) {
 160                 perror("seek");
 161                 goto out;
 162         }
 163
 164         ret = read(mem, source, sizeof(source));
 165         if (ret < 0) {
 166                 perror("read");
 167                 goto out;
 168         }
 169
 170         if (lseek(mem, req->data.args[1], SEEK_SET) < 0) {
 171                 perror("seek");
 172                 goto out;
 173         }
 174
 175         ret = read(mem, target, sizeof(target));
 176         if (ret < 0) {
 177                 perror("read");
 178                 goto out;
 179         }
 180
 181         /*
 182          * Our policy is to only allow bind mounts inside /tmp. This isn't very
 183          * interesting, because we could do unprivlieged bind mounts with user
 184          * namespaces already, but you get the idea.
 185          */
 186         if (!strncmp(source, "/tmp/", 5) && !strncmp(target, "/tmp/", 5)) {
 187                 if (mount(source, target, NULL, req->data.args[3], NULL) < 0) {
 188                         ret = -1;
 189                         perror("actual mount");
 190                         goto out;
 191                 }
 192                 resp->error = 0;
 193         }
 194
 195         /* Even if we didn't allow it because of policy, generating the
 196          * response was be a success, because we want to tell the worker EPERM.
 197          */
 198         ret = 0;
 199
 200 out:
 201         close(mem);
 202         return ret;
 203 }
 204
 205 int main(void)
 206 {
 207         int sk_pair[2], ret = 1, status, listener;
 208         pid_t worker = 0 , tracer = 0;
 209
 210         if (socketpair(PF_LOCAL, SOCK_SEQPACKET, 0, sk_pair) < 0) {
 211                 perror("socketpair");
 212                 return 1;
 213         }
 214
 215         worker = fork();
 216         if (worker < 0) {
 217                 perror("fork");
 218                 goto close_pair;
 219         }
 220
 221         if (worker == 0) {
 222                 listener = user_trap_syscall(__NR_mount,
 223                                              SECCOMP_FILTER_FLAG_NEW_LISTENER);
 224                 if (listener < 0) {
 225                         perror("seccomp");
 226                         exit(1);
 227                 }
 228
 229                 /*
 230                  * Drop privileges. We definitely can't mount as uid 1000.
 231                  */
 232                 if (setuid(1000) < 0) {
 233                         perror("setuid");
 234                         exit(1);
 235                 }
 236
 237                 /*
 238                  * Send the listener to the parent; also serves as
 239                  * synchronization.
 240                  */
 241                 if (send_fd(sk_pair[1], listener) < 0)
 242                         exit(1);
 243                 close(listener);
 244
 245                 if (mkdir("/tmp/foo", 0755) < 0) {
 246                         perror("mkdir");
 247                         exit(1);
 248                 }
 249
 250                 /*
 251                  * Try a bad mount just for grins.
 252                  */
 253                 if (mount("/dev/sda", "/tmp/foo", NULL, 0, NULL) != -1) {
 254                         fprintf(stderr, "huh? mounted /dev/sda?\n");
 255                         exit(1);
 256                 }
 257
 258                 if (errno != EPERM) {
 259                         perror("bad error from mount");
 260                         exit(1);
 261                 }
 262
 263                 /*
 264                  * Ok, we expect this one to succeed.
 265                  */
 266                 if (mount("/tmp/foo", "/tmp/foo", NULL, MS_BIND, NULL) < 0) {
 267                         perror("mount");
 268                         exit(1);
 269                 }
 270
 271                 exit(0);
 272         }
 273
 274         /*
 275          * Get the listener from the child.
 276          */
 277         listener = recv_fd(sk_pair[0]);
 278         if (listener < 0)
 279                 goto out_kill;
 280
 281         /*
 282          * Fork a task to handle the requests. This isn't strictly necessary,
 283          * but it makes the particular writing of this sample easier, since we
 284          * can just wait ofr the tracee to exit and kill the tracer.
 285          */
 286         tracer = fork();
 287         if (tracer < 0) {
 288                 perror("fork");
 289                 goto out_kill;
 290         }
 291
 292         if (tracer == 0) {
 293                 struct seccomp_notif *req;
 294                 struct seccomp_notif_resp *resp;
 295                 struct seccomp_notif_sizes sizes;
 296
 297                 if (seccomp(SECCOMP_GET_NOTIF_SIZES, 0, &sizes) < 0) {
 298                         perror("seccomp(GET_NOTIF_SIZES)");
 299                         goto out_close;
 300                 }
 301
 302                 req = malloc(sizes.seccomp_notif);
 303                 if (!req)
 304                         goto out_close;
 305
 306                 resp = malloc(sizes.seccomp_notif_resp);
 307                 if (!resp)
 308                         goto out_req;
 309                 memset(resp, 0, sizes.seccomp_notif_resp);
 310
 311                 while (1) {
 312                         memset(req, 0, sizes.seccomp_notif);
 313                         if (ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, req)) {
 314                                 perror("ioctl recv");
 315                                 goto out_resp;
 316                         }
 317
 318                         if (handle_req(req, resp, listener) < 0)
 319                                 goto out_resp;
 320
 321                         /*
 322                          * ENOENT here means that the task may have gotten a
 323                          * signal and restarted the syscall. It's up to the
 324                          * handler to decide what to do in this case, but for
 325                          * the sample code, we just ignore it. Probably
 326                          * something better should happen, like undoing the
 327                          * mount, or keeping track of the args to make sure we
 328                          * don't do it again.
 329                          */
 330                         if (ioctl(listener, SECCOMP_IOCTL_NOTIF_SEND, resp) < 0 &&
 331                             errno != ENOENT) {
 332                                 perror("ioctl send");
 333                                 goto out_resp;
 334                         }
 335                 }
 336 out_resp:
 337                 free(resp);
 338 out_req:
 339                 free(req);
 340 out_close:
 341                 close(listener);
 342                 exit(1);
 343         }
 344
 345         close(listener);
 346
 347         if (waitpid(worker, &status, 0) != worker) {
 348                 perror("waitpid");
 349                 goto out_kill;
 350         }
 351
 352         if (umount2("/tmp/foo", MNT_DETACH) < 0 && errno != EINVAL) {
 353                 perror("umount2");
 354                 goto out_kill;
 355         }
 356
 357         if (remove("/tmp/foo") < 0 && errno != ENOENT) {
 358                 perror("remove");
 359                 exit(1);
 360         }
 361
 362         if (!WIFEXITED(status) || WEXITSTATUS(status)) {
 363                 fprintf(stderr, "worker exited nonzero\n");
 364                 goto out_kill;
 365         }
 366
 367         ret = 0;
 368
 369 out_kill:
 370         if (tracer > 0)
 371                 kill(tracer, SIGKILL);
 372         if (worker > 0)
 373                 kill(worker, SIGKILL);
 374
 375 close_pair:
 376         close(sk_pair[0]);
 377         close(sk_pair[1]);
 378         return ret;
 379 }