src/box.c

   1 /*
   2  *      A Simple Testing Sandbox
   3  *
   4  *      (c) 2001--2007 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #define _LARGEFILE64_SOURCE
   8 #define _GNU_SOURCE
   9
  10 #include <errno.h>
  11 #include <stdio.h>
  12 #include <fcntl.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <stdarg.h>
  16 #include <unistd.h>
  17 #include <getopt.h>
  18 #include <time.h>
  19 #include <sys/wait.h>
  20 #include <sys/user.h>
  21 #include <sys/time.h>
  22 #include <sys/ptrace.h>
  23 #include <sys/signal.h>
  24 #include <sys/sysinfo.h>
  25 #include <sys/syscall.h>
  26 #include <sys/resource.h>
  27
  28 #define NONRET __attribute__((noreturn))
  29 #define UNUSED __attribute__((unused))
  30
  31 static int filter_syscalls;             /* 0=off, 1=liberal, 2=totalitarian */
  32 static int timeout;                     /* milliseconds */
  33 static int wall_timeout;
  34 static int pass_environ;
  35 static int file_access;
  36 static int verbose;
  37 static int memory_limit;
  38 static int allow_times;
  39 static char *redir_stdin, *redir_stdout;
  40 static char *set_cwd;
  41
  42 static pid_t box_pid;
  43 static int is_ptraced;
  44 static volatile int timer_tick;
  45 static struct timeval start_time;
  46 static int ticks_per_sec;
  47
  48 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ > 0
  49 /* glibc 2.1 or newer -> has lseek64 */
  50 #define long_seek(f,o,w) lseek64(f,o,w)
  51 #else
  52 /* Touching clandestine places in glibc */
  53 extern loff_t llseek(int fd, loff_t pos, int whence);
  54 #define long_seek(f,o,w) llseek(f,o,w)
  55 #endif
  56
  57 static void NONRET
  58 box_exit(void)
  59 {
  60   if (box_pid > 0)
  61     {
  62       if (is_ptraced)
  63         ptrace(PTRACE_KILL, box_pid);
  64       kill(-box_pid, SIGKILL);
  65       kill(box_pid, SIGKILL);
  66     }
  67   exit(1);
  68 }
  69
  70 static void NONRET __attribute__((format(printf,1,2)))
  71 die(char *msg, ...)
  72 {
  73   va_list args;
  74   va_start(args, msg);
  75   vfprintf(stderr, msg, args);
  76   fputc('\n', stderr);
  77   box_exit();
  78 }
  79
  80 static void __attribute__((format(printf,1,2)))
  81 log(char *msg, ...)
  82 {
  83   va_list args;
  84   va_start(args, msg);
  85   if (verbose)
  86     {
  87       vfprintf(stderr, msg, args);
  88       fflush(stderr);
  89     }
  90   va_end(args);
  91 }
  92
  93 static void
  94 valid_filename(unsigned long addr)
  95 {
  96   char namebuf[4096], *p, *end;
  97   static int mem_fd;
  98
  99   if (!file_access)
 100     die("File access forbidden.");
 101   if (file_access >= 9)
 102     return;
 103
 104   if (!mem_fd)
 105     {
 106       sprintf(namebuf, "/proc/%d/mem", (int) box_pid);
 107       mem_fd = open(namebuf, O_RDONLY);
 108       if (mem_fd < 0)
 109         die("open(%s): %m", namebuf);
 110     }
 111   p = end = namebuf;
 112   do
 113     {
 114       if (p >= end)
 115         {
 116           int remains = PAGE_SIZE - (addr & (PAGE_SIZE-1));
 117           int l = namebuf + sizeof(namebuf) - end;
 118           if (l > remains)
 119             l = remains;
 120           if (!l)
 121             die("Access to file with name too long.");
 122           if (long_seek(mem_fd, addr, SEEK_SET) < 0)
 123             die("long_seek(mem): %m");
 124           remains = read(mem_fd, end, l);
 125           if (remains < 0)
 126             die("read(mem): %m");
 127           if (!remains)
 128             die("Access to file with name out of memory.");
 129           end += l;
 130           addr += l;
 131         }
 132     }
 133   while (*p++);
 134
 135   log("[%s] ", namebuf);
 136   if (file_access >= 3)
 137     return;
 138   if (!strchr(namebuf, '/') && strcmp(namebuf, ".."))
 139     return;
 140   if (file_access >= 2)
 141     {
 142       if ((!strncmp(namebuf, "/etc/", 5) ||
 143            !strncmp(namebuf, "/lib/", 5) ||
 144            !strncmp(namebuf, "/usr/lib/", 9) ||
 145            !strncmp(namebuf, "/opt/lib/", 9))
 146           && !strstr(namebuf, ".."))
 147         return;
 148       if (!strcmp(namebuf, "/dev/null") ||
 149           !strcmp(namebuf, "/dev/zero") ||
 150           !strcmp(namebuf, "/proc/meminfo") ||
 151           !strcmp(namebuf, "/proc/self/stat") ||
 152           !strcmp(namebuf, "/proc/self/exe") ||                 /* Needed by FPC 2.0.x runtime */
 153           !strncmp(namebuf, "/usr/share/zoneinfo/", 20))
 154         return;
 155     }
 156   die("Forbidden access to file `%s'.", namebuf);
 157 }
 158
 159 static int
 160 valid_syscall(struct user *u)
 161 {
 162   switch (u->regs.orig_eax)
 163     {
 164     case __NR_execve:
 165       {
 166         static int exec_counter;
 167         return !exec_counter++;
 168       }
 169     case __NR_open:
 170     case __NR_creat:
 171     case __NR_unlink:
 172     case __NR_oldstat:
 173     case __NR_access:
 174     case __NR_oldlstat:
 175     case __NR_truncate:
 176     case __NR_stat:
 177     case __NR_lstat:
 178     case __NR_truncate64:
 179     case __NR_stat64:
 180     case __NR_lstat64:
 181     case __NR_readlink:
 182       valid_filename(u->regs.ebx);
 183       return 1;
 184     case __NR_exit:
 185     case __NR_read:
 186     case __NR_write:
 187     case __NR_close:
 188     case __NR_lseek:
 189     case __NR_getpid:
 190     case __NR_getuid:
 191     case __NR_oldfstat:
 192     case __NR_dup:
 193     case __NR_brk:
 194     case __NR_getgid:
 195     case __NR_geteuid:
 196     case __NR_getegid:
 197     case __NR_dup2:
 198     case __NR_ftruncate:
 199     case __NR_fstat:
 200     case __NR_personality:
 201     case __NR__llseek:
 202     case __NR_readv:
 203     case __NR_writev:
 204     case __NR_getresuid:
 205 #ifdef __NR_pread64
 206     case __NR_pread64:
 207     case __NR_pwrite64:
 208 #else
 209     case __NR_pread:
 210     case __NR_pwrite:
 211 #endif
 212     case __NR_ftruncate64:
 213     case __NR_fstat64:
 214     case __NR_fcntl:
 215     case __NR_fcntl64:
 216     case __NR_mmap:
 217     case __NR_munmap:
 218     case __NR_ioctl:
 219     case __NR_uname:
 220     case __NR_gettid:
 221     case __NR_set_thread_area:
 222     case __NR_get_thread_area:
 223     case __NR_exit_group:
 224       return 1;
 225     case __NR_time:
 226     case __NR_alarm:
 227     case __NR_pause:
 228     case __NR_signal:
 229     case __NR_fchmod:
 230     case __NR_sigaction:
 231     case __NR_sgetmask:
 232     case __NR_ssetmask:
 233     case __NR_sigsuspend:
 234     case __NR_sigpending:
 235     case __NR_getrlimit:
 236     case __NR_getrusage:
 237     case __NR_gettimeofday:
 238     case __NR_select:
 239     case __NR_readdir:
 240     case __NR_setitimer:
 241     case __NR_getitimer:
 242     case __NR_sigreturn:
 243     case __NR_mprotect:
 244     case __NR_sigprocmask:
 245     case __NR_getdents:
 246     case __NR_getdents64:
 247     case __NR__newselect:
 248     case __NR_fdatasync:
 249     case __NR_mremap:
 250     case __NR_poll:
 251     case __NR_getcwd:
 252     case __NR_nanosleep:
 253     case __NR_rt_sigreturn:
 254     case __NR_rt_sigaction:
 255     case __NR_rt_sigprocmask:
 256     case __NR_rt_sigpending:
 257     case __NR_rt_sigtimedwait:
 258     case __NR_rt_sigqueueinfo:
 259     case __NR_rt_sigsuspend:
 260     case __NR_mmap2:
 261     case __NR__sysctl:
 262       return (filter_syscalls == 1);
 263     case __NR_times:
 264       return allow_times;
 265     case __NR_kill:
 266       if (u->regs.ebx == box_pid)
 267         die("Commited suicide by signal %d.", (int)u->regs.ecx);
 268       return 0;
 269     case __NR_tgkill:
 270       if (u->regs.ebx == box_pid && u->regs.ecx == box_pid)
 271         die("Commited suicide by signal %d.", (int)u->regs.edx);
 272       return 0;
 273     default:
 274       return 0;
 275     }
 276 }
 277
 278 static void
 279 signal_alarm(int unused UNUSED)
 280 {
 281   /* Time limit checks are synchronous, so we only schedule them there. */
 282   timer_tick = 1;
 283   alarm(1);
 284 }
 285
 286 static void
 287 signal_int(int unused UNUSED)
 288 {
 289   /* Interrupts are fatal, so no synchronization requirements. */
 290   die("Interrupted.");
 291 }
 292
 293 static void
 294 check_timeout(void)
 295 {
 296   if (wall_timeout)
 297     {
 298       struct timeval now, wall;
 299       int wall_ms;
 300       gettimeofday(&now, NULL);
 301       timersub(&now, &start_time, &wall);
 302       wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
 303       if (wall_ms > wall_timeout)
 304         die("Time limit exceeded (wall clock)");
 305       if (verbose > 1)
 306         fprintf(stderr, "[wall time check: %d msec]\n", wall_ms);
 307     }
 308   if (timeout)
 309     {
 310       char buf[4096], *x;
 311       int c, utime, stime, ms;
 312       static int proc_status_fd;
 313       if (!proc_status_fd)
 314         {
 315           sprintf(buf, "/proc/%d/stat", (int) box_pid);
 316           proc_status_fd = open(buf, O_RDONLY);
 317           if (proc_status_fd < 0)
 318             die("open(%s): %m", buf);
 319         }
 320       lseek(proc_status_fd, 0, SEEK_SET);
 321       if ((c = read(proc_status_fd, buf, sizeof(buf)-1)) < 0)
 322         die("read on /proc/$pid/stat: %m");
 323       if (c >= (int) sizeof(buf) - 1)
 324         die("/proc/$pid/stat too long");
 325       buf[c] = 0;
 326       x = buf;
 327       while (*x && *x != ' ')
 328         x++;
 329       while (*x == ' ')
 330         x++;
 331       if (*x++ != '(')
 332         die("proc syntax error 1");
 333       while (*x && (*x != ')' || x[1] != ' '))
 334         x++;
 335       while (*x == ')' || *x == ' ')
 336         x++;
 337       if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
 338         die("proc syntax error 2");
 339       ms = (utime + stime) * 1000 / ticks_per_sec;
 340       if (verbose > 1)
 341         fprintf(stderr, "[time check: %d msec]\n", ms);
 342       if (ms > timeout)
 343         die("Time limit exceeded");
 344     }
 345 }
 346
 347 static void
 348 boxkeeper(void)
 349 {
 350   int syscall_count = 0;
 351   struct sigaction sa;
 352
 353   is_ptraced = 1;
 354   bzero(&sa, sizeof(sa));
 355   sa.sa_handler = signal_int;
 356   sigaction(SIGINT, &sa, NULL);
 357   gettimeofday(&start_time, NULL);
 358   ticks_per_sec = sysconf(_SC_CLK_TCK);
 359   if (ticks_per_sec <= 0)
 360     die("Invalid ticks_per_sec!");
 361   if (timeout || wall_timeout)
 362     {
 363       sa.sa_handler = signal_alarm;
 364       sigaction(SIGALRM, &sa, NULL);
 365       alarm(1);
 366     }
 367   for(;;)
 368     {
 369       struct rusage rus;
 370       int stat;
 371       pid_t p;
 372       if (timer_tick)
 373         {
 374           check_timeout();
 375           timer_tick = 0;
 376         }
 377       p = wait4(box_pid, &stat, WUNTRACED, &rus);
 378       if (p < 0)
 379         {
 380           if (errno == EINTR)
 381             continue;
 382           die("wait4: %m");
 383         }
 384       if (p != box_pid)
 385         die("wait4: unknown pid %d exited!", p);
 386       if (WIFEXITED(stat))
 387         {
 388           struct timeval total, now, wall;
 389           int total_ms, wall_ms;
 390           box_pid = 0;
 391           if (WEXITSTATUS(stat))
 392             die("Exited with error status %d.", WEXITSTATUS(stat));
 393           timeradd(&rus.ru_utime, &rus.ru_stime, &total);
 394           total_ms = total.tv_sec*1000 + total.tv_usec/1000;
 395           gettimeofday(&now, NULL);
 396           timersub(&now, &start_time, &wall);
 397           wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
 398           if (timeout && total_ms > timeout)
 399             die("Time limit exceeded.");
 400           if (wall_timeout && wall_ms > wall_timeout)
 401             die("Time limit exceeded (wall clock.");
 402           fprintf(stderr, "OK (%d.%03d sec real, %d.%03d sec wall, %d syscalls)\n",
 403               (int) total.tv_sec, (int) total.tv_usec/1000,
 404               (int) wall.tv_sec, (int) wall.tv_usec/1000,
 405               syscall_count);
 406           exit(0);
 407         }
 408       if (WIFSIGNALED(stat))
 409         {
 410           box_pid = 0;
 411           die("Caught fatal signal %d.", WTERMSIG(stat));
 412         }
 413       if (WIFSTOPPED(stat))
 414         {
 415           int sig = WSTOPSIG(stat);
 416           if (sig == SIGTRAP)
 417             {
 418               struct user u;
 419               static int stop_count = -1;
 420               if (ptrace(PTRACE_GETREGS, box_pid, NULL, &u) < 0)
 421                 die("ptrace(PTRACE_GETREGS): %m");
 422               stop_count++;
 423               if (!stop_count)                  /* Traceme request */
 424                 log(">> Traceme request caught\n");
 425               else if (stop_count & 1)          /* Syscall entry */
 426                 {
 427                   log(">> Syscall %3ld (%08lx,%08lx,%08lx) ", u.regs.orig_eax, u.regs.ebx, u.regs.ecx, u.regs.edx);
 428                   syscall_count++;
 429                   if (!valid_syscall(&u))
 430                     {
 431                       /*
 432                        * Unfortunately, PTRACE_KILL kills _after_ the syscall completes,
 433                        * so we have to change it to something harmless (e.g., an undefined
 434                        * syscall) and make the program continue.
 435                        */
 436                       unsigned int sys = u.regs.orig_eax;
 437                       u.regs.orig_eax = 0xffffffff;
 438                       if (ptrace(PTRACE_SETREGS, box_pid, NULL, &u) < 0)
 439                         die("ptrace(PTRACE_SETREGS): %m");
 440                       die("Forbidden syscall %d.", sys);
 441                     }
 442                 }
 443               else                                      /* Syscall return */
 444                 log("= %ld\n", u.regs.eax);
 445               ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
 446             }
 447           else if (sig != SIGSTOP && sig != SIGXCPU && sig != SIGXFSZ)
 448             {
 449               log(">> Signal %d\n", sig);
 450               ptrace(PTRACE_SYSCALL, box_pid, 0, sig);
 451             }
 452           else
 453             die("Received signal %d.", sig);
 454         }
 455       else
 456         die("wait4: unknown status %x, giving up!", stat);
 457     }
 458 }
 459
 460 static void
 461 box_inside(int argc, char **argv)
 462 {
 463   struct rlimit rl;
 464   char *args[argc+1];
 465   char *env[1] = { NULL };
 466
 467   memcpy(args, argv, argc * sizeof(char *));
 468   args[argc] = NULL;
 469   if (set_cwd && chdir(set_cwd))
 470     die("chdir: %m");
 471   if (redir_stdin)
 472     {
 473       close(0);
 474       if (open(redir_stdin, O_RDONLY) != 0)
 475         die("open(\"%s\"): %m", redir_stdin);
 476     }
 477   if (redir_stdout)
 478     {
 479       close(1);
 480       if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
 481         die("open(\"%s\"): %m", redir_stdout);
 482     }
 483   dup2(1, 2);
 484   setpgrp();
 485   if (memory_limit)
 486     {
 487       rl.rlim_cur = rl.rlim_max = memory_limit * 1024;
 488       if (setrlimit(RLIMIT_AS, &rl) < 0)
 489         die("setrlimit: %m");
 490     }
 491   rl.rlim_cur = rl.rlim_max = 64;
 492   if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
 493     die("setrlimit: %m");
 494   if (filter_syscalls && ptrace(PTRACE_TRACEME) < 0)
 495     die("ptrace(PTRACE_TRACEME): %m");
 496   execve(args[0], args, (pass_environ ? environ : env));
 497   die("execve(\"%s\"): %m", args[0]);
 498 }
 499
 500 static void
 501 usage(void)
 502 {
 503   fprintf(stderr, "Invalid arguments!\n");
 504   printf("\
 505 Usage: box [<options>] -- <command> <arguments>\n\
 506 \n\
 507 Options:\n\
 508 -a <level>\tSet file access level (0=none, 1=cwd, 2=/etc,/lib,..., 3=whole fs, 9=no checks; needs -f)\n\
 509 -c <dir>\tChange directory to <dir> first\n\
 510 -e\t\tPass full environment of parent process\n\
 511 -f\t\tFilter system calls (-ff=very restricted)\n\
 512 -i <file>\tRedirect stdin from <file>\n\
 513 -m <size>\tLimit address space to <size> KB\n\
 514 -o <file>\tRedirect stdout to <file>\n\
 515 -t <time>\tSet run time limit (seconds, fractions allowed)\n\
 516 -T\t\tAllow syscalls for measuring run time\n\
 517 -v\t\tBe verbose\n\
 518 -w <time>\tSet wall clock time limit (seconds, fractions allowed)\n\
 519 ");
 520   exit(1);
 521 }
 522
 523 int
 524 main(int argc, char **argv)
 525 {
 526   int c;
 527   uid_t uid;
 528
 529   while ((c = getopt(argc, argv, "a:c:efi:m:o:t:Tvw:")) >= 0)
 530     switch (c)
 531       {
 532       case 'a':
 533         file_access = atol(optarg);
 534         break;
 535       case 'c':
 536         set_cwd = optarg;
 537         break;
 538       case 'e':
 539         pass_environ = 1;
 540         break;
 541       case 'f':
 542         filter_syscalls++;
 543         break;
 544       case 'i':
 545         redir_stdin = optarg;
 546         break;
 547       case 'm':
 548         memory_limit = atol(optarg);
 549         break;
 550       case 'o':
 551         redir_stdout = optarg;
 552         break;
 553       case 't':
 554         timeout = 1000*atof(optarg);
 555         break;
 556       case 'T':
 557         allow_times++;
 558         break;
 559       case 'v':
 560         verbose++;
 561         break;
 562       case 'w':
 563         wall_timeout = 1000*atof(optarg);
 564         break;
 565       default:
 566         usage();
 567       }
 568   if (optind >= argc)
 569     usage();
 570
 571   uid = geteuid();
 572   if (setreuid(uid, uid) < 0)
 573     die("setreuid: %m");
 574   box_pid = fork();
 575   if (box_pid < 0)
 576     die("fork: %m");
 577   if (!box_pid)
 578     box_inside(argc-optind, argv+optind);
 579   else
 580     boxkeeper();
 581   die("Internal error: fell over edge of the world");
 582 }