]> mj.ucw.cz Git - eval.git/blob - src/box.c
Added a switch for allowing timing syscalls.
[eval.git] / src / box.c
1 /*
2  *      A Simple Testing Sandbox
3  *
4  *      (c) 2001 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;
33 static int pass_environ;
34 static int use_wall_clock;
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
41 static pid_t box_pid;
42 static int is_ptraced;
43 static volatile int timer_tick;
44 static time_t start_time;
45 static int ticks_per_sec;
46
47 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ > 0
48 /* glibc 2.1 or newer -> has lseek64 */
49 #define long_seek(f,o,w) lseek64(f,o,w)
50 #else
51 /* Touching clandestine places in glibc */
52 extern loff_t llseek(int fd, loff_t pos, int whence);
53 #define long_seek(f,o,w) llseek(f,o,w)
54 #endif
55
56 static void NONRET
57 box_exit(void)
58 {
59   if (box_pid > 0)
60     {
61       if (is_ptraced)
62         ptrace(PTRACE_KILL, box_pid);
63       kill(-box_pid, SIGKILL);
64       kill(box_pid, SIGKILL);
65     }
66   exit(1);
67 }
68
69 static void NONRET __attribute__((format(printf,1,2)))
70 die(char *msg, ...)
71 {
72   va_list args;
73   va_start(args, msg);
74   vfprintf(stderr, msg, args);
75   fputc('\n', stderr);
76   box_exit();
77 }
78
79 static void __attribute__((format(printf,1,2)))
80 log(char *msg, ...)
81 {
82   va_list args;
83   va_start(args, msg);
84   if (verbose)
85     {
86       vfprintf(stderr, msg, args);
87       fflush(stderr);
88     }
89   va_end(args);
90 }
91
92 static void
93 valid_filename(unsigned long addr)
94 {
95   char namebuf[4096], *p, *end;
96   static int mem_fd;
97
98   if (!file_access)
99     die("File access forbidden.");
100   if (file_access >= 9)
101     return;
102
103   if (!mem_fd)
104     {
105       sprintf(namebuf, "/proc/%d/mem", (int) box_pid);
106       mem_fd = open(namebuf, O_RDONLY);
107       if (mem_fd < 0)
108         die("open(%s): %m", namebuf);
109     }
110   p = end = namebuf;
111   do
112     {
113       if (p >= end)
114         {
115           int remains = PAGE_SIZE - (addr & (PAGE_SIZE-1));
116           int l = namebuf + sizeof(namebuf) - end;
117           if (l > remains)
118             l = remains;
119           if (!l)
120             die("Access to file with name too long.");
121           if (long_seek(mem_fd, addr, SEEK_SET) < 0)
122             die("long_seek(mem): %m");
123           remains = read(mem_fd, end, l);
124           if (remains < 0)
125             die("read(mem): %m");
126           if (!remains)
127             die("Access to file with name out of memory.");
128           end += l;
129           addr += l;
130         }
131     }
132   while (*p++);
133
134   log("[%s] ", namebuf);
135   if (file_access >= 3)
136     return;
137   if (!strchr(namebuf, '/') && strcmp(namebuf, ".."))
138     return;
139   if (file_access >= 2)
140     {
141       if ((!strncmp(namebuf, "/etc/", 5) ||
142            !strncmp(namebuf, "/lib/", 5) ||
143            !strncmp(namebuf, "/usr/lib/", 9))
144           && !strstr(namebuf, ".."))
145         return;
146       if (!strcmp(namebuf, "/dev/null") ||
147           !strcmp(namebuf, "/dev/zero") ||
148           !strcmp(namebuf, "/proc/meminfo") ||
149           !strcmp(namebuf, "/proc/self/stat") ||
150           !strncmp(namebuf, "/usr/share/zoneinfo/", 20))
151         return;
152     }
153   die("Forbidden access to file `%s'.", namebuf);
154 }
155
156 static int
157 valid_syscall(struct user *u)
158 {
159   switch (u->regs.orig_eax)
160     {
161     case SYS_execve:
162       {
163         static int exec_counter;
164         return !exec_counter++;
165       }
166     case SYS_open:
167     case SYS_creat:
168     case SYS_unlink:
169     case SYS_oldstat:
170     case SYS_access:                    
171     case SYS_oldlstat:                  
172     case SYS_truncate:
173     case SYS_stat:
174     case SYS_lstat:
175     case SYS_truncate64:
176     case SYS_stat64:
177     case SYS_lstat64:
178       valid_filename(u->regs.ebx);
179       return 1;
180     case SYS_exit:
181     case SYS_read:
182     case SYS_write:
183     case SYS_close:
184     case SYS_lseek:
185     case SYS_getpid:
186     case SYS_getuid:
187     case SYS_oldfstat:
188     case SYS_dup:
189     case SYS_brk:
190     case SYS_getgid:
191     case SYS_geteuid:
192     case SYS_getegid:
193     case SYS_dup2:
194     case SYS_ftruncate:
195     case SYS_fstat:
196     case SYS_personality:
197     case SYS__llseek:
198     case SYS_readv:
199     case SYS_writev:
200     case SYS_getresuid:
201     case SYS_pread:
202     case SYS_pwrite:
203     case SYS_ftruncate64:
204     case SYS_fstat64:
205     case SYS_fcntl:
206     case SYS_fcntl64:
207     case SYS_mmap:
208     case SYS_munmap:
209     case SYS_ioctl:
210     case SYS_uname:
211     case 252:
212       return 1;
213     case SYS_time:
214     case SYS_alarm:
215     case SYS_pause:
216     case SYS_signal:
217     case SYS_fchmod:
218     case SYS_sigaction:
219     case SYS_sgetmask:
220     case SYS_ssetmask:
221     case SYS_sigsuspend:
222     case SYS_sigpending:
223     case SYS_getrlimit:
224     case SYS_getrusage:
225     case SYS_gettimeofday:
226     case SYS_select:
227     case SYS_readdir:
228     case SYS_setitimer:
229     case SYS_getitimer:
230     case SYS_sigreturn:
231     case SYS_mprotect:
232     case SYS_sigprocmask:
233     case SYS_getdents:
234     case SYS_getdents64:
235     case SYS__newselect:
236     case SYS_fdatasync:
237     case SYS_mremap:
238     case SYS_poll:
239     case SYS_getcwd:
240     case SYS_nanosleep:
241     case SYS_rt_sigreturn:
242     case SYS_rt_sigaction:
243     case SYS_rt_sigprocmask:
244     case SYS_rt_sigpending:
245     case SYS_rt_sigtimedwait:
246     case SYS_rt_sigqueueinfo:
247     case SYS_rt_sigsuspend:
248     case SYS_mmap2:
249     case SYS__sysctl:
250       return (filter_syscalls == 1);
251     case SYS_times:
252       return allow_times;
253     default:
254       return 0;
255     }
256 }
257
258 static void
259 signal_alarm(int unused UNUSED)
260 {
261   /* Time limit checks are synchronous, so we only schedule them there. */
262   timer_tick = 1;
263   alarm(1);
264 }
265
266 static void
267 signal_int(int unused UNUSED)
268 {
269   /* Interrupts are fatal, so no synchronization requirements. */
270   die("Interrupted.");
271 }
272
273 static void
274 check_timeout(void)
275 {
276   int sec;
277
278   if (use_wall_clock)
279     sec = time(NULL) - start_time;
280   else
281     {
282       char buf[4096], *x;
283       int c, utime, stime;
284       static int proc_status_fd;
285       if (!proc_status_fd)
286         {
287           sprintf(buf, "/proc/%d/stat", (int) box_pid);
288           proc_status_fd = open(buf, O_RDONLY);
289           if (proc_status_fd < 0)
290             die("open(%s): %m", buf);
291         }
292       lseek(proc_status_fd, 0, SEEK_SET);
293       if ((c = read(proc_status_fd, buf, sizeof(buf)-1)) < 0)
294         die("read on /proc/$pid/stat: %m");
295       if (c >= (int) sizeof(buf) - 1)
296         die("/proc/$pid/stat too long");
297       buf[c] = 0;
298       x = buf;
299       while (*x && *x != ' ')
300         x++;
301       while (*x == ' ')
302         x++;
303       if (*x++ != '(')
304         die("proc syntax error 1");
305       while (*x && (*x != ')' || x[1] != ' '))
306         x++;
307       while (*x == ')' || *x == ' ')
308         x++;
309       if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
310         die("proc syntax error 2");
311       sec = (utime + stime)/ticks_per_sec;
312     }
313   if (verbose > 1)
314     fprintf(stderr, "[timecheck: %d seconds]\n", sec);
315   if (sec > timeout)
316     die("Time limit exceeded.");
317 }
318
319 static void
320 boxkeeper(void)
321 {
322   int syscall_count = 0;
323   struct sigaction sa;
324
325   is_ptraced = 1;
326   bzero(&sa, sizeof(sa));
327   sa.sa_handler = signal_int;
328   sigaction(SIGINT, &sa, NULL);
329   start_time = time(NULL);
330   ticks_per_sec = sysconf(_SC_CLK_TCK);
331   if (ticks_per_sec <= 0)
332     die("Invalid ticks_per_sec!");
333   if (timeout)
334     {
335       sa.sa_handler = signal_alarm;
336       sigaction(SIGALRM, &sa, NULL);
337       alarm(1);
338     }
339   for(;;)
340     {
341       struct rusage rus;
342       int stat;
343       pid_t p;
344       if (timer_tick)
345         {
346           check_timeout();
347           timer_tick = 0;
348         }
349       p = wait4(box_pid, &stat, WUNTRACED, &rus);
350       if (p < 0)
351         {
352           if (errno == EINTR)
353             continue;
354           die("wait4: %m");
355         }
356       if (p != box_pid)
357         die("wait4: unknown pid %d exited!", p);
358       if (WIFEXITED(stat))
359         {
360           struct timeval total;
361           int wall;
362           box_pid = 0;
363           if (WEXITSTATUS(stat))
364             die("Exited with error status %d.", WEXITSTATUS(stat));
365           timeradd(&rus.ru_utime, &rus.ru_stime, &total);
366           wall = time(NULL) - start_time;
367           if ((use_wall_clock ? wall : total.tv_sec) > timeout)
368             die("Time limit exceeded (after exit).");
369           fprintf(stderr, "OK (%d sec real, %d sec wall, %d syscalls)\n", (int) total.tv_sec, wall, syscall_count);
370           exit(0);
371         }
372       if (WIFSIGNALED(stat))
373         {
374           box_pid = 0;
375           die("Caught fatal signal %d.", WTERMSIG(stat));
376         }
377       if (WIFSTOPPED(stat))
378         {
379           int sig = WSTOPSIG(stat);
380           if (sig == SIGTRAP)
381             {
382               struct user u;
383               static int stop_count = -1;
384               if (ptrace(PTRACE_GETREGS, box_pid, NULL, &u) < 0)
385                 die("ptrace(PTRACE_GETREGS): %m");
386               stop_count++;
387               if (!stop_count)                  /* Traceme request */
388                 log(">> Traceme request caught\n");
389               else if (stop_count & 1)          /* Syscall entry */
390                 {
391                   log(">> Syscall %3ld (%08lx,%08lx,%08lx) ", u.regs.orig_eax, u.regs.ebx, u.regs.ecx, u.regs.edx);
392                   syscall_count++;
393                   if (!valid_syscall(&u))
394                     {
395                       /*
396                        * Unfortunately, PTRACE_KILL kills _after_ the syscall completes,
397                        * so we have to change it to something harmless (e.g., an undefined
398                        * syscall) and make the program continue.
399                        */
400                       unsigned int sys = u.regs.orig_eax;
401                       u.regs.orig_eax = 0xffffffff;
402                       if (ptrace(PTRACE_SETREGS, box_pid, NULL, &u) < 0)
403                         die("ptrace(PTRACE_SETREGS): %m");
404                       die("Forbidden syscall %d.", sys);
405                     }
406                 }
407               else                                      /* Syscall return */
408                 log("= %ld\n", u.regs.eax);
409               ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
410             }
411           else if (sig != SIGSTOP && sig != SIGXCPU && sig != SIGXFSZ)
412             {
413               log(">> Signal %d\n", sig);
414               ptrace(PTRACE_SYSCALL, box_pid, 0, sig);
415             }
416           else
417             die("Received signal %d.", sig);
418         }
419       else
420         die("wait4: unknown status %x, giving up!", stat);
421     }
422 }
423
424 static void
425 box_inside(int argc, char **argv)
426 {
427   struct rlimit rl;
428   char *args[argc+1];
429   char *env[1] = { NULL };
430
431   memcpy(args, argv, argc * sizeof(char *));
432   args[argc] = NULL;
433   if (redir_stdin)
434     {
435       close(0);
436       if (open(redir_stdin, O_RDONLY) != 0)
437         die("open(\"%s\"): %m", redir_stdin);
438     }
439   if (redir_stdout)
440     {
441       close(1);
442       if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
443         die("open(\"%s\"): %m", redir_stdout);
444     }
445   close(2);
446   dup(1);
447   setpgrp();
448   if (memory_limit)
449     {
450       rl.rlim_cur = rl.rlim_max = memory_limit * 1024;
451       if (setrlimit(RLIMIT_AS, &rl) < 0)
452         die("setrlimit: %m");
453     }
454   rl.rlim_cur = rl.rlim_max = 64;
455   if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
456     die("setrlimit: %m");
457   if (filter_syscalls && ptrace(PTRACE_TRACEME) < 0)
458     die("ptrace(PTRACE_TRACEME): %m");
459   execve(args[0], args, (pass_environ ? environ : env));
460   die("execve(\"%s\"): %m", args[0]);
461 }
462
463 static void
464 usage(void)
465 {
466   fprintf(stderr, "Invalid arguments!\n");
467   printf("\
468 Usage: box [<options>] -- <command> <arguments>\n\
469 \n\
470 Options:\n\
471 -a <level>\tSet file access level (0=none, 1=cwd, 2=/etc,/lib,..., 3=whole fs, 9=no checks; needs -f)\n\
472 -c <dir>\tChange directory to <dir> first\n\
473 -e\t\tPass full environment of parent process\n\
474 -f\t\tFilter system calls (-ff=very restricted)\n\
475 -i <file>\tRedirect stdin from <file>\n\
476 -m <size>\tLimit address space to <size> KB\n\
477 -o <file>\tRedirect stdout to <file>\n\
478 -t <time>\tStop after <time> seconds\n\
479 -T\t\tAllow syscalls for measuring run time\n\
480 -v\t\tBe verbose\n\
481 -w\t\tMeasure wall clock time instead of run time\n\
482 ");
483   exit(1);
484 }
485
486 int
487 main(int argc, char **argv)
488 {
489   int c;
490   uid_t uid;
491   char *cwd = NULL;
492
493   while ((c = getopt(argc, argv, "a:c:efi:m:o:t:Tvw")) >= 0)
494     switch (c)
495       {
496       case 'a':
497         file_access = atol(optarg);
498         break;
499       case 'c':
500         cwd = optarg;
501         break;
502       case 'e':
503         pass_environ = 1;
504         break;
505       case 'f':
506         filter_syscalls++;
507         break;
508       case 'i':
509         redir_stdin = optarg;
510         break;
511       case 'm':
512         memory_limit = atol(optarg);
513         break;
514       case 'o':
515         redir_stdout = optarg;
516         break;
517       case 't':
518         timeout = atol(optarg);
519         break;
520       case 'T':
521         allow_times++;
522         break;
523       case 'v':
524         verbose++;
525         break;
526       case 'w':
527         use_wall_clock = 1;
528         break;
529       default:
530         usage();
531       }
532   if (optind >= argc)
533     usage();
534
535   uid = geteuid();
536   if (setreuid(uid, uid) < 0)
537     die("setreuid: %m");
538   if (cwd && chdir(cwd))
539     die("chdir: %m");
540   box_pid = fork();
541   if (box_pid < 0)
542     die("fork: %m");
543   if (!box_pid)
544     box_inside(argc-optind, argv+optind);
545   else
546     boxkeeper();
547   die("Internal error: fell over edge of the world");
548 }