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