src/vsh.c

   1 /*
   2  * Marc E. Fiuczynski <mef@cs.princeton.edu>
   3  *
   4  * Copyright (c) 2004 The Trustees of Princeton University (Trustees).
   5  *
   6  * vsh is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2, or (at your option)
   9  * any later version.
  10  *
  11  * vsh is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  14  * License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Poptop; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #  include <config.h>
  24 #endif
  25 #include "compat.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <pwd.h>
  33 #include <unistd.h>
  34 #include <syscall.h>
  35 #include <sys/syscall.h>
  36 #include <asm/unistd.h>
  37 #include <sys/mount.h>
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <sys/resource.h>
  41 #include <fcntl.h>
  42 #include <ctype.h>
  43 #include <stdarg.h>
  44
  45 //--------------------------------------------------------------------
  46 #include "vserver.h"
  47
  48 #undef CONFIG_VSERVER_LEGACY
  49
  50 /* Null byte made explicit */
  51 #define NULLBYTE_SIZE                    1
  52
  53 /* Base for all vserver roots for chroot */
  54 #define VSERVER_ROOT_BASE       "/vservers"
  55
  56 static int
  57 _PERROR(const char *format, char *file, int line, int _errno, ...)
  58 {
  59         va_list ap;
  60
  61         va_start(ap, _errno);
  62         fprintf(stderr, "%s:%d: ", file, line);
  63         vfprintf(stderr, format, ap);
  64         if (_errno)
  65                 fprintf(stderr, ": %s (%d)", strerror(_errno), _errno);
  66         fputs("\n", stderr);
  67         fflush(stderr);
  68
  69         return _errno;
  70 }
  71
  72 #define PERROR(format, args...) _PERROR(format, __FILE__, __LINE__, errno, ## args)
  73
  74 /* Change to root:root (before entering new context) */
  75 static int setuidgid_root()
  76 {
  77         if (setgid(0) < 0) {
  78                 PERROR("setgid(0)");
  79                 return -1;
  80         }
  81         if (setuid(0) < 0) {
  82                 PERROR("setuid(0)");
  83                 return -1;
  84         }
  85         return 0;
  86 }
  87
  88 static void compute_new_root(char *base, char **root, uid_t uid)
  89 {
  90         int             root_len;
  91         struct passwd   *pwd;
  92
  93         if ((pwd = getpwuid(uid)) == NULL) {
  94                 PERROR("getpwuid(%d)", uid);
  95                 exit(1);
  96         }
  97
  98         root_len =
  99                 strlen(base) + strlen("/") +
 100                 strlen(pwd->pw_name)      + NULLBYTE_SIZE;
 101         (*root) = (char *)malloc(root_len);
 102         if ((*root) == NULL) {
 103                 PERROR("malloc(%d)", root_len);
 104                 exit(1);
 105         }
 106
 107         sprintf((*root), "%s/%s", base, pwd->pw_name);
 108         (*root)[root_len - 1] = '\0';
 109 }
 110
 111 /* Example: sandbox_root = /vservers/bnc, relpath = /proc/1 */
 112 static int sandbox_file_exists(char *sandbox_root, char *relpath)
 113 {
 114         struct stat stat_buf;
 115         char   *file;
 116         int    len, exists = 0;
 117
 118         len = strlen(sandbox_root) + strlen(relpath) + NULLBYTE_SIZE;
 119         if ((file = (char *)malloc(len)) == NULL) {
 120                 PERROR("malloc(%d)", len);
 121                 exit(1);
 122         }
 123         sprintf(file, "%s%s", sandbox_root, relpath);
 124         file[len - 1] = '\0';
 125         if (stat(file, &stat_buf) == 0) {
 126                 exists = 1;
 127         }
 128
 129
 130         free(file);
 131         return exists;
 132 }
 133
 134 static int proc_mounted(char *sandbox_root)
 135 {
 136         return sandbox_file_exists(sandbox_root, "/proc/1");
 137 }
 138
 139 static int devpts_mounted(char *sandbox_root)
 140 {
 141         return sandbox_file_exists(sandbox_root, "/dev/pts/0");
 142 }
 143
 144 static void mount_proc(char *sandbox_root)
 145 {
 146         char        *source = "/proc";
 147         char        *target;
 148         int         len;
 149
 150         len = strlen(sandbox_root) + strlen("/") + strlen("proc") + NULLBYTE_SIZE;
 151         if ((target = (char *)malloc(len)) == NULL) {
 152                 PERROR("malloc(%d)", len);
 153                 exit(1);
 154         }
 155
 156         sprintf(target, "%s/proc", sandbox_root);
 157         target[len - 1] = '\0';
 158         if (!proc_mounted(sandbox_root))
 159                 mount(source, target, "proc", MS_BIND | MS_RDONLY, NULL);
 160
 161         free(target);
 162 }
 163
 164 static void mount_devpts(char *sandbox_root)
 165 {
 166         char        *source = "/dev/pts";
 167         char        *target;
 168         int         len;
 169
 170         len = strlen(sandbox_root) + strlen("/") + strlen("dev/pts") + NULLBYTE_SIZE;
 171         if ((target = (char *)malloc(len)) == NULL) {
 172                 PERROR("malloc(%d)", len);
 173                 exit(1);
 174         }
 175
 176         sprintf(target, "%s/dev/pts", sandbox_root);
 177         target[len - 1] = '\0';
 178         if (!devpts_mounted(sandbox_root))
 179                 mount(source, target, "devpts", 0, NULL);
 180
 181         free(target);
 182 }
 183
 184 static int sandbox_chroot(uid_t uid)
 185 {
 186         char *sandbox_root = NULL;
 187
 188         compute_new_root(VSERVER_ROOT_BASE,&sandbox_root, uid);
 189         mount_proc(sandbox_root);
 190         mount_devpts(sandbox_root);
 191         if (chroot(sandbox_root) < 0) {
 192                 PERROR("chroot(%s)", sandbox_root);
 193                 exit(1);
 194         }
 195         if (chdir("/") < 0) {
 196                 PERROR("chdir(/)");
 197                 exit(1);
 198         }
 199         return 0;
 200 }
 201
 202 #define WHITESPACE(buffer,index,len)     \
 203   while(isspace((int)buffer[index])) \
 204         if (index < len) index++; else goto out;
 205
 206 struct resources {
 207         char *name;
 208         int *limit;
 209 };
 210
 211 #define VSERVERCONF "/etc/vservers/"
 212 static void get_limits(char *context, int *cpu, int *mem, int *task) {
 213         FILE *fb;
 214         size_t len = strlen(VSERVERCONF) + strlen(context) + strlen(".conf") + NULLBYTE_SIZE;
 215         char *conf = (char *)malloc(len);
 216         struct resources list[] =
 217                 {{"MEMLIMIT", mem},
 218                  {"CPULIMIT", cpu},
 219                  {"TASKLIMIT", task},
 220                  {0,0}};
 221         struct resources *r;
 222
 223         sprintf(conf, "%s%s.conf", VSERVERCONF, context);
 224
 225         /* open the conf file for reading */
 226         fb = fopen(conf,"r");
 227         if (fb != NULL) {
 228                 size_t index;
 229                 char *buffer = malloc(1000);
 230                 char *p;
 231
 232                 /* the conf file exist */
 233                 while((p=fgets(buffer,1000-1,fb))!=NULL) {
 234                         index = 0;
 235                         len = strnlen(buffer,1000);
 236                         WHITESPACE(buffer,index,len);
 237                         if (buffer[index] == '#')
 238                                 continue;
 239
 240                         for (r=list; r->name; r++)
 241                                 if ((p=strstr(&buffer[index],r->name))!=NULL) {
 242                                         /* adjust index into buffer */
 243                                         index+= (p-&buffer[index])+strlen(r->name);
 244
 245                                         /* skip over whitespace */
 246                                         WHITESPACE(buffer,index,len);
 247
 248                                         /* expecting to see = sign */
 249                                         if (buffer[index++]!='=') goto out;
 250
 251                                         /* skip over whitespace */
 252                                         WHITESPACE(buffer,index,len);
 253
 254                                         /* expecting to see a digit for number */
 255                                         if (!isdigit((int)buffer[index])) goto out;
 256
 257                                         *r->limit = atoi(&buffer[index]);
 258                                         break;
 259                                 }
 260                 }
 261         out:
 262                 free(buffer);
 263         } else {
 264                 fprintf(stderr,"cannot open %s\n",conf);
 265         }
 266         free(conf);
 267 }
 268
 269
 270 static int sandbox_processes(xid_t xid, char *context)
 271 {
 272 #ifdef CONFIG_VSERVER_LEGACY
 273         int     flags;
 274
 275         flags = 0;
 276         flags |= 1; /* VX_INFO_LOCK -- cannot request a new vx_id */
 277         /* flags |= 4; VX_INFO_NPROC -- limit number of procs in a context */
 278
 279         (void) vc_new_s_context(xid, 0, flags);
 280
 281         /* use legacy dirty hack for capremove */
 282         if (vc_new_s_context(VC_SAMECTX, vc_get_insecurebcaps(), flags) == VC_NOCTX) {
 283                 PERROR("vc_new_s_context(%u, 0x%16ullx, 0x%08x)",
 284                        VC_SAMECTX, vc_get_insecurebcaps(), flags);
 285                 exit(1);
 286         }
 287 #else
 288         struct vc_rlimit limits;
 289         struct vc_ctx_caps caps;
 290         struct vc_ctx_flags flags;
 291         int ctx;
 292         int cpu = VC_LIM_KEEP;
 293         int mem = VC_LIM_KEEP;
 294         int task = VC_LIM_KEEP;
 295         get_limits(context,&cpu, &mem, &task);
 296         (void) (sandbox_chroot(xid));
 297
 298         caps.ccaps = ~vc_get_insecureccaps();
 299         caps.cmask = ~0ull;
 300         caps.bcaps = ~vc_get_insecurebcaps();
 301         caps.bmask = ~0ull;
 302
 303         flags.flagword = VC_VXF_INFO_LOCK;
 304         flags.mask = VC_VXF_STATE_SETUP | VC_VXF_INFO_LOCK;
 305
 306         ctx = vc_ctx_create(xid);
 307         if (ctx == VC_NOCTX && errno != EEXIST) {
 308                 PERROR("vc_ctx_create(%d)", xid);
 309                 exit(1);
 310         }
 311
 312         /* (re)set the various limits on the (possibly new) context */
 313
 314         /* CPU    */
 315         /* not yet */
 316
 317         /* MEM    */
 318         limits.min  = VC_LIM_KEEP;
 319         limits.soft = VC_LIM_KEEP;
 320         limits.hard = mem;
 321         if (vc_set_rlimit(xid, RLIMIT_RSS, &limits)) {
 322                 PERROR("vc_set_rlimit(%d, %d, %d/%d/%d)",
 323                        xid, RLIMIT_RSS, limits.min, limits.soft, limits.hard);
 324                 exit(1);
 325         }
 326
 327         /* TASK   */
 328         limits.min  = VC_LIM_KEEP;
 329         limits.soft = VC_LIM_KEEP;
 330         limits.hard = task;
 331         if (vc_set_rlimit(xid, RLIMIT_NPROC, &limits)) {
 332                 PERROR("vc_set_rlimit(%d, %d, %d/%d/%d)",
 333                        xid, RLIMIT_NPROC, limits.min, limits.soft, limits.hard);
 334                 exit(1);
 335         }
 336
 337         if (vc_set_ccaps(xid, &caps) == -1) {
 338                 PERROR("vc_set_ccaps(%d, 0x%16ullx/0x%16ullx, 0x%16ullx/0x%16ullx)",
 339                        xid, caps.ccaps, caps.cmask, caps.bcaps, caps.bmask);
 340                 exit(1);
 341         }
 342
 343         if (vc_set_cflags(xid, &flags) == -1) {
 344                 PERROR("vc_set_cflags(%d, 0x%16llx/0x%16llx)",
 345                        xid, flags.flagword, flags.mask);
 346                 exit(1);
 347         }
 348
 349         /* context already exists, migrate to it */
 350         if (ctx == VC_NOCTX && vc_ctx_migrate(xid) == -1) {
 351                 PERROR("vc_ctx_migrate(%d)", xid);
 352                 exit(1);
 353         }
 354 #endif
 355         return 0;
 356 }
 357
 358
 359 void runas_slice_user(char *username)
 360 {
 361         struct passwd pwdd, *pwd = &pwdd, *result;
 362         char          *pwdBuffer;
 363         char          *home_env, *logname_env, *mail_env, *shell_env, *user_env;
 364         int           home_len, logname_len, mail_len, shell_len, user_len;
 365         long          pwdBuffer_len;
 366         static char   *envp[10];
 367
 368
 369         pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 370         if (pwdBuffer_len == -1) {
 371                 PERROR("sysconf(_SC_GETPW_R_SIZE_MAX)");
 372                 exit(1);
 373         }
 374
 375         pwdBuffer = (char*)malloc(pwdBuffer_len);
 376         if (pwdBuffer == NULL) {
 377                 PERROR("malloc(%d)", pwdBuffer_len);
 378                 exit(1);
 379         }
 380
 381         errno = 0;
 382         if ((getpwnam_r(username,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 383                 PERROR("getpwnam_r(%s)", username);
 384                 exit(1);
 385         }
 386
 387         if (setgid(pwd->pw_gid) < 0) {
 388                 PERROR("setgid(%d)", pwd->pw_gid);
 389                 exit(1);
 390         }
 391
 392         if (setuid(pwd->pw_uid) < 0) {
 393                 PERROR("setuid(%d)", pwd->pw_uid);
 394                 exit(1);
 395         }
 396
 397         if (chdir(pwd->pw_dir) < 0) {
 398                 PERROR("chdir(%s)", pwd->pw_dir);
 399                 exit(1);
 400         }
 401
 402         home_len    = strlen("HOME=") + strlen(pwd->pw_dir) + NULLBYTE_SIZE;
 403         logname_len = strlen("LOGNAME=") + strlen(username) + NULLBYTE_SIZE;
 404         mail_len    = strlen("MAIL=/var/spool/mail/") + strlen(username)
 405                 + NULLBYTE_SIZE;
 406         shell_len   = strlen("SHELL=") + strlen(pwd->pw_shell) + NULLBYTE_SIZE;
 407         user_len    = strlen("USER=") + strlen(username) + NULLBYTE_SIZE;
 408
 409         home_env    = (char *)malloc(home_len);
 410         logname_env = (char *)malloc(logname_len);
 411         mail_env    = (char *)malloc(mail_len);
 412         shell_env   = (char *)malloc(shell_len);
 413         user_env    = (char *)malloc(user_len);
 414
 415         if ((home_env    == NULL)  ||
 416             (logname_env == NULL)  ||
 417             (mail_env    == NULL)  ||
 418             (shell_env   == NULL)  ||
 419             (user_env    == NULL)) {
 420                 PERROR("malloc");
 421                 exit(1);
 422         }
 423
 424         sprintf(home_env, "HOME=%s", pwd->pw_dir);
 425         sprintf(logname_env, "LOGNAME=%s", username);
 426         sprintf(mail_env, "MAIL=/var/spool/mail/%s", username);
 427         sprintf(shell_env, "SHELL=%s", pwd->pw_shell);
 428         sprintf(user_env, "USER=%s", username);
 429
 430         home_env[home_len - 1]       = '\0';
 431         logname_env[logname_len - 1] = '\0';
 432         mail_env[mail_len - 1]       = '\0';
 433         shell_env[shell_len - 1]     = '\0';
 434         user_env[user_len - 1]       = '\0';
 435
 436         envp[0] = home_env;
 437         envp[1] = logname_env;
 438         envp[2] = mail_env;
 439         envp[3] = shell_env;
 440         envp[4] = user_env;
 441         envp[5] = 0;
 442
 443         if ((putenv(home_env)    < 0) ||
 444             (putenv(logname_env) < 0) ||
 445             (putenv(mail_env)    < 0) ||
 446             (putenv(shell_env)   < 0) ||
 447             (putenv(user_env)    < 0)) {
 448                 PERROR("vserver: putenv error ");
 449                 exit(1);
 450         }
 451 }
 452
 453 void slice_enter(char *context)
 454 {
 455         struct passwd pwdd, *pwd = &pwdd, *result;
 456         char          *pwdBuffer;
 457         long          pwdBuffer_len;
 458         uid_t uid;
 459
 460         pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 461         if (pwdBuffer_len == -1) {
 462                 PERROR("sysconf(_SC_GETPW_R_SIZE_MAX)");
 463                 exit(1);
 464         }
 465
 466         pwdBuffer = (char*)malloc(pwdBuffer_len);
 467         if (pwdBuffer == NULL) {
 468                 PERROR("malloc(%d)", pwdBuffer_len);
 469                 exit(1);
 470         }
 471
 472         errno = 0;
 473         if ((getpwnam_r(context,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 474                 PERROR("getpwnam_r(%s)", context);
 475                 exit(2);
 476         }
 477         uid = pwd->pw_uid;
 478
 479         if (setuidgid_root() < 0) { /* For chroot, new_s_context */
 480                 fprintf(stderr, "vsh: Could not become root, check that SUID flag is set on binary\n");
 481                 exit(2);
 482         }
 483
 484 #ifdef CONFIG_VSERVER_LEGACY
 485         (void) (sandbox_chroot(uid));
 486 #endif
 487
 488         if (sandbox_processes((xid_t) uid, context) < 0) {
 489                 fprintf(stderr, "vsh: Could not change context to %d\n", uid);
 490                 exit(2);
 491         }
 492 }
 493
 494 //--------------------------------------------------------------------
 495
 496 #define DEFAULT_SHELL "/bin/sh"
 497
 498 /* Exit statuses for programs like 'env' that exec other programs.
 499    EXIT_FAILURE might not be 1, so use EXIT_FAIL in such programs.  */
 500 enum
 501 {
 502   EXIT_CANNOT_INVOKE = 126,
 503   EXIT_ENOENT = 127
 504 };
 505
 506 int main(int argc, char **argv)
 507 {
 508     struct passwd   pwdd, *pwd = &pwdd, *result;
 509     char            *context, *username, *shell, *pwdBuffer;
 510     long            pwdBuffer_len;
 511     uid_t           uid;
 512     int             index, i;
 513
 514     if (argv[0][0]=='-')
 515       index = 1;
 516     else
 517       index = 0;
 518
 519     uid = getuid();
 520     if ((pwd = getpwuid(uid)) == NULL) {
 521       PERROR("getpwuid(%d)", uid);
 522       exit(1);
 523     }
 524
 525     context = (char*)strdup(pwd->pw_name);
 526     if (!context) {
 527       PERROR("strdup");
 528       exit(2);
 529     }
 530
 531     /* enter vserver "context" */
 532     slice_enter(context);
 533
 534     /* Now run as username in this context. Note that for PlanetLab's
 535        vserver configuration the context name also happens to be the
 536        "default" username within the vserver context.
 537     */
 538     username = context;
 539     runas_slice_user(username);
 540
 541     /* With the uid/gid appropriately set. Let's figure out what the
 542      * shell in the vserver's /etc/passwd is for the given username.
 543      */
 544
 545     pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 546     if (pwdBuffer_len == -1) {
 547             PERROR("sysconf(_SC_GETPW_R_SIZE_MAX");
 548             exit(1);
 549     }
 550     pwdBuffer = (char*)malloc(pwdBuffer_len);
 551     if (pwdBuffer == NULL) {
 552             PERROR("malloc(%d)", pwdBuffer_len);
 553             exit(1);
 554     }
 555
 556     errno = 0;
 557     if ((getpwnam_r(username,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 558         PERROR("getpwnam_r(%s)", username);
 559         exit(1);
 560     }
 561
 562     /* Make sure pw->pw_shell is non-NULL.*/
 563     if (pwd->pw_shell == NULL || pwd->pw_shell[0] == '\0') {
 564       pwd->pw_shell = (char *) DEFAULT_SHELL;
 565     }
 566
 567     shell = (char *)strdup(pwd->pw_shell);
 568     if (!shell) {
 569       PERROR("strdup");
 570       exit(2);
 571     }
 572
 573     /* Check whether 'su' or 'sshd' invoked us as a login shell or
 574        not; did this above when testing argv[0]=='-'.
 575     */
 576     argv[0] = shell;
 577     if (index == 1) {
 578       char **args;
 579       args = (char**)malloc(sizeof(char*)*(argc+2));
 580       if (!args) {
 581         PERROR("malloc(%d)", sizeof(char*)*(argc+2));
 582         exit(1);
 583       }
 584       args[0] = argv[0];
 585       args[1] = "-l";
 586       for(i=1;i<argc+1;i++) {
 587         args[i+1] = argv[i];
 588       }
 589       argv = args;
 590     }
 591     (void) execvp(shell,argv);
 592     {
 593       int exit_status = (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 594       exit (exit_status);
 595     }
 596
 597     return 0; /* shutup compiler */
 598 }