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 <fcntl.h>
  41 #include <ctype.h>
  42
  43 //--------------------------------------------------------------------
  44 #include "linuxcaps.h"
  45 #include "vserver.h"
  46
  47 /* Null byte made explicit */
  48 #define NULLBYTE_SIZE                    1
  49
  50 /* Base for all vserver roots for chroot */
  51 #define VSERVER_ROOT_BASE       "/vservers"
  52
  53 /* Change to root:root (before entering new context) */
  54 static int setuidgid_root()
  55 {
  56         if (setgid(0) < 0) {
  57                 fprintf(stderr, "setgid error\n");
  58                 return -1;
  59         }
  60         if (setuid(0) < 0) {
  61                 fprintf(stderr, "setuid error\n");
  62                 return -1;
  63         }
  64         return 0;
  65 }
  66
  67 static void compute_new_root(char *base, char **root, uid_t uid)
  68 {
  69         int             root_len;
  70         struct passwd   *pwd;
  71
  72         if ((pwd = getpwuid(uid)) == NULL) {
  73                 perror("vserver: getpwuid error ");
  74                 exit(1);
  75         }
  76
  77         root_len =
  78                 strlen(base) + strlen("/") +
  79                 strlen(pwd->pw_name)      + NULLBYTE_SIZE;
  80         (*root) = (char *)malloc(root_len);
  81         if ((*root) == NULL) {
  82                 perror("vserver: malloc error ");
  83                 exit(1);
  84         }
  85
  86         sprintf((*root), "%s/%s", base, pwd->pw_name);
  87         (*root)[root_len - 1] = '\0';
  88 }
  89
  90 /* Example: sandbox_root = /vservers/bnc, relpath = /proc/1 */
  91 static int sandbox_file_exists(char *sandbox_root, char *relpath)
  92 {
  93         struct stat stat_buf;
  94         char   *file;
  95         int    len, exists = 0;
  96
  97         len = strlen(sandbox_root) + strlen(relpath) + NULLBYTE_SIZE;
  98         if ((file = (char *)malloc(len)) == NULL) {
  99                 perror("vserver: malloc error ");
 100                 exit(1);
 101         }
 102         sprintf(file, "%s%s", sandbox_root, relpath);
 103         file[len - 1] = '\0';
 104         if (stat(file, &stat_buf) == 0) {
 105                 exists = 1;
 106         }
 107
 108
 109         free(file);
 110         return exists;
 111 }
 112
 113 static int proc_mounted(char *sandbox_root)
 114 {
 115         return sandbox_file_exists(sandbox_root, "/proc/1");
 116 }
 117
 118 static int devpts_mounted(char *sandbox_root)
 119 {
 120         return sandbox_file_exists(sandbox_root, "/dev/pts/0");
 121 }
 122
 123 static void mount_proc(char *sandbox_root,uid_t uid)
 124 {
 125         char        *source = "/proc";
 126         char        *target;
 127         int         len;
 128
 129         len = strlen(sandbox_root) + strlen("/") + strlen("proc") + NULLBYTE_SIZE;
 130         if ((target = (char *)malloc(len)) == NULL) {
 131                 perror("vserver: malloc error ");
 132                 exit(1);
 133         }
 134
 135         sprintf(target, "%s/proc", sandbox_root);
 136         target[len - 1] = '\0';
 137         if (!proc_mounted(sandbox_root))
 138                 mount(source, target, "proc", MS_BIND | MS_RDONLY, NULL);
 139
 140         free(target);
 141 }
 142
 143 static void mount_devpts(char *sandbox_root)
 144 {
 145         char        *source = "/dev/pts";
 146         char        *target;
 147         int         len;
 148
 149         len = strlen(sandbox_root) + strlen("/") + strlen("dev/pts") + NULLBYTE_SIZE;
 150         if ((target = (char *)malloc(len)) == NULL) {
 151                 perror("vserver: malloc error ");
 152                 exit(1);
 153         }
 154
 155         sprintf(target, "%s/dev/pts", sandbox_root);
 156         target[len - 1] = '\0';
 157         if (!devpts_mounted(sandbox_root))
 158                 mount(source, target, "devpts", 0, NULL);
 159
 160         free(target);
 161 }
 162
 163 static int sandbox_chroot(uid_t uid)
 164 {
 165         char *sandbox_root = NULL;
 166
 167         compute_new_root(VSERVER_ROOT_BASE,&sandbox_root, uid);
 168         mount_proc(sandbox_root,uid);
 169         mount_devpts(sandbox_root);
 170         if (chroot(sandbox_root) < 0) {
 171                 fprintf(stderr,"vserver: chroot error (%s): ",sandbox_root);
 172                 perror("");
 173                 exit(1);
 174         }
 175         if (chdir("/") < 0) {
 176                 perror("vserver: chdir error ");
 177                 exit(1);
 178         }
 179         return 0;
 180 }
 181
 182 #ifndef CAP_CONTEXT
 183 #  define CAP_CONTEXT   29
 184 #endif
 185
 186 static struct {
 187         const char *option;
 188         int bit;
 189 }tbcap[]={
 190         // The following capabilities are normally available
 191         // to vservers administrator, but are place for
 192         // completeness
 193         {"CAP_CHOWN",CAP_CHOWN},
 194         {"CAP_DAC_OVERRIDE",CAP_DAC_OVERRIDE},
 195         {"CAP_DAC_READ_SEARCH",CAP_DAC_READ_SEARCH},
 196         {"CAP_FOWNER",CAP_FOWNER},
 197         {"CAP_FSETID",CAP_FSETID},
 198         {"CAP_KILL",CAP_KILL},
 199         {"CAP_SETGID",CAP_SETGID},
 200         {"CAP_SETUID",CAP_SETUID},
 201         {"CAP_SETPCAP",CAP_SETPCAP},
 202         {"CAP_SYS_TTY_CONFIG",CAP_SYS_TTY_CONFIG},
 203         {"CAP_LEASE",CAP_LEASE},
 204         {"CAP_SYS_CHROOT",CAP_SYS_CHROOT},
 205
 206         // Those capabilities are not normally available
 207         // to vservers because they are not needed and
 208         // may represent a security risk
 209         {"CAP_LINUX_IMMUTABLE",CAP_LINUX_IMMUTABLE},
 210         {"CAP_NET_BIND_SERVICE",CAP_NET_BIND_SERVICE},
 211         {"CAP_NET_BROADCAST",CAP_NET_BROADCAST},
 212         {"CAP_NET_ADMIN",       CAP_NET_ADMIN},
 213         {"CAP_NET_RAW", CAP_NET_RAW},
 214         {"CAP_IPC_LOCK",        CAP_IPC_LOCK},
 215         {"CAP_IPC_OWNER",       CAP_IPC_OWNER},
 216         {"CAP_SYS_MODULE",CAP_SYS_MODULE},
 217         {"CAP_SYS_RAWIO",       CAP_SYS_RAWIO},
 218         {"CAP_SYS_PACCT",       CAP_SYS_PACCT},
 219         {"CAP_SYS_ADMIN",       CAP_SYS_ADMIN},
 220         {"CAP_SYS_BOOT",        CAP_SYS_BOOT},
 221         {"CAP_SYS_NICE",        CAP_SYS_NICE},
 222         {"CAP_SYS_RESOURCE",CAP_SYS_RESOURCE},
 223         {"CAP_SYS_TIME",        CAP_SYS_TIME},
 224         {"CAP_MKNOD",           CAP_MKNOD},
 225         {"CAP_CONTEXT",         CAP_CONTEXT},
 226         {NULL,0}
 227 };
 228
 229 #define VSERVERCONF "/etc/vservers/"
 230 static unsigned get_remove_cap(char *name) {
 231         FILE     *fb;
 232         unsigned remove_cap;
 233
 234         char *vserverconf;
 235         int vserverconflen;
 236
 237         remove_cap = /* NOTE: keep in sync with chcontext.c */
 238                 (1<<CAP_LINUX_IMMUTABLE)|
 239                 (1<<CAP_NET_BIND_SERVICE)|
 240                 (1<<CAP_NET_BROADCAST)|
 241                 (1<<CAP_NET_ADMIN)|
 242                 (1<<CAP_NET_RAW)|
 243                 (1<<CAP_IPC_LOCK)|
 244                 (1<<CAP_IPC_OWNER)|
 245                 (1<<CAP_SYS_MODULE)|
 246                 (1<<CAP_SYS_RAWIO)|
 247                 (1<<CAP_SYS_PACCT)|
 248                 (1<<CAP_SYS_ADMIN)|
 249                 (1<<CAP_SYS_BOOT)|
 250                 (1<<CAP_SYS_NICE)|
 251                 (1<<CAP_SYS_RESOURCE)|
 252                 (1<<CAP_SYS_TIME)|
 253                 (1<<CAP_MKNOD)|
 254                 (1<<CAP_CONTEXT)|
 255                 0
 256                 ;
 257
 258         /*
 259          * find out which capabilities to put back in by reading the conf file
 260          */
 261
 262         /* construct the pathname to the conf file */
 263         vserverconflen = strlen(VSERVERCONF) + strlen(name) + strlen(".conf") + NULLBYTE_SIZE;
 264         vserverconf    = (char *)malloc(vserverconflen);
 265         sprintf(vserverconf, "%s%s.conf", VSERVERCONF, name);
 266
 267         /* open the conf file for reading */
 268         fb = fopen(vserverconf,"r");
 269         if (fb != NULL) {
 270                 unsigned cap;
 271                 size_t index;
 272                 size_t len;
 273                 char buffer[1000], *p;
 274
 275                 /* the conf file file exist */
 276                 while((p=fgets(buffer,sizeof(buffer)-1,fb))!=NULL) {
 277
 278                         /* walk past leading spaces */
 279                         index = 0;
 280                         len = strnlen(buffer,sizeof(buffer)-1);
 281                         while(isspace((int)buffer[index])) {
 282                                 if (index < len) {
 283                                         index++;
 284                                 } else {
 285                                         goto out;
 286                                 }
 287                         }
 288
 289                         if (buffer[index] == '#') continue;
 290
 291                         /* check if it is the S_CAPS */
 292                         if ((p=strstr(&buffer[index],"S_CAPS"))!=NULL) {
 293                                 int j;
 294                                 cap = 0;
 295
 296                                 /* what follows is a bunch of error
 297                                    checking to parse the S_CAPS="..."
 298                                    string */
 299
 300                                 /* adjust index into buffer */
 301                                 index+= (p-&buffer[index])+strlen("S_CAPS");
 302
 303                                 /* skip over whitespace */
 304                                 while(isspace((int)buffer[index])) {
 305                                         if (index < len) {
 306                                                 index++;
 307                                         } else {
 308                                         /* parse error */
 309                                                 goto out;
 310                                         }
 311                                 }
 312
 313                                 /* expecting to see = sign */
 314                                 if (buffer[index++]!='=') {
 315                                         /* parse error */
 316                                         goto out;
 317                                 }
 318
 319                                 /* skip over whitespace */
 320                                 while(isspace((int)buffer[index])) {
 321                                         if (index < len) {
 322                                                 index++;
 323                                         } else {
 324                                                 /* parse error */
 325                                                 goto out;
 326                                         }
 327                                 }
 328
 329                                 /* expecting to see the opening " */
 330                                 if (buffer[index]!='"') {
 331                                         /* parse error */
 332                                         goto out;
 333                                 }
 334
 335                                 /* check to see that we are still within bounds */
 336                                 if (index < len) {
 337                                         index++;
 338                                 } else {
 339                                         /* parse error */
 340                                         goto out;
 341                                 }
 342
 343                                 /* search for the closing " */
 344                                 if((p=strstr(&buffer[index],"\""))==NULL) {
 345                                         /* parse error */
 346                                         goto out;
 347                                 }
 348
 349                                 /* ok... we should now have a bunch of
 350                                    CAP keys words within the quotes */
 351
 352                                 for (j=0; tbcap[j].option != NULL; j++){
 353                                         if ((p=strstr(buffer,tbcap[j].option))!=NULL){
 354                                                 len = strlen(tbcap[j].option);
 355                                                 if (((isspace(*(p-1))) || (*(p-1)=='"')) &&
 356                                                     ((isspace(*(p+len))) || (*(p+len)=='"'))) {
 357                                                         cap |= (1<<tbcap[j].bit);
 358                                                 } else {
 359                                                         /* parse error */
 360                                                         goto out;
 361                                                 }
 362                                         }
 363                                 }
 364                                 remove_cap &= ~cap;
 365                                 break;
 366                         }
 367                 }
 368  out:
 369                 /* close the conf file */
 370                 fclose(fb);
 371         }
 372         return remove_cap;
 373 }
 374
 375 static int sandbox_processes(uid_t uid, unsigned remove_cap)
 376 {
 377         int      context;
 378         int      flags;
 379
 380         /* Unique context */
 381         context = uid;
 382
 383         flags = 0;
 384         flags |= 1; /* VX_INFO_LOCK -- cannot request a new vx_id */
 385         /* flags |= 4; VX_INFO_NPROC -- limit number of procs in a context */
 386
 387         if (vc_new_s_context(context,remove_cap,flags) < 0) {
 388                 perror("vserver: new_s_context error ");
 389                 exit(1);
 390         }
 391         return 0;
 392 }
 393
 394
 395 void runas_slice_user(char *username)
 396 {
 397         struct passwd pwdd, *pwd = &pwdd, *result;
 398         char          *pwdBuffer;
 399         char          *home_env, *logname_env, *mail_env, *shell_env, *user_env;
 400         int           home_len, logname_len, mail_len, shell_len, user_len;
 401         long          pwdBuffer_len;
 402         static char   *envp[10];
 403
 404
 405         pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 406         if (pwdBuffer_len == -1) {
 407                 perror("vserver: _SC_GETPW_R_SIZE_MAX not defined ");
 408                 exit(1);
 409         }
 410
 411         pwdBuffer = (char*)malloc(pwdBuffer_len);
 412         if (pwdBuffer == NULL) {
 413                 perror("vserver: malloc error ");
 414                 exit(1);
 415         }
 416
 417         errno = 0;
 418         if ((getpwnam_r(username,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 419                 perror("vserver: getpwnam error ");
 420                 exit(1);
 421         }
 422
 423         if (setgid(pwd->pw_gid) < 0) {
 424                 perror("vserver: setgid error ");
 425                 exit(1);
 426         }
 427
 428         if (setuid(pwd->pw_uid) < 0) {
 429                 perror("vserver: setuid error ");
 430                 exit(1);
 431         }
 432
 433         if (chdir(pwd->pw_dir) < 0) {
 434                 perror("vserver: chdir error ");
 435                 exit(1);
 436         }
 437
 438         home_len    = strlen("HOME=") + strlen(pwd->pw_dir) + NULLBYTE_SIZE;
 439         logname_len = strlen("LOGNAME=") + strlen(username) + NULLBYTE_SIZE;
 440         mail_len    = strlen("MAIL=/var/spool/mail/") + strlen(username)
 441                 + NULLBYTE_SIZE;
 442         shell_len   = strlen("SHELL=") + strlen(pwd->pw_shell) + NULLBYTE_SIZE;
 443         user_len    = strlen("USER=") + strlen(username) + NULLBYTE_SIZE;
 444
 445         home_env    = (char *)malloc(home_len);
 446         logname_env = (char *)malloc(logname_len);
 447         mail_env    = (char *)malloc(mail_len);
 448         shell_env   = (char *)malloc(shell_len);
 449         user_env    = (char *)malloc(user_len);
 450
 451         if ((home_env    == NULL)  ||
 452             (logname_env == NULL)  ||
 453             (mail_env    == NULL)  ||
 454             (shell_env   == NULL)  ||
 455             (user_env    == NULL)) {
 456                 perror("vserver: malloc error ");
 457                 exit(1);
 458         }
 459
 460         sprintf(home_env, "HOME=%s", pwd->pw_dir);
 461         sprintf(logname_env, "LOGNAME=%s", username);
 462         sprintf(mail_env, "MAIL=/var/spool/mail/%s", username);
 463         sprintf(shell_env, "SHELL=%s", pwd->pw_shell);
 464         sprintf(user_env, "USER=%s", username);
 465
 466         home_env[home_len - 1]       = '\0';
 467         logname_env[logname_len - 1] = '\0';
 468         mail_env[mail_len - 1]       = '\0';
 469         shell_env[shell_len - 1]     = '\0';
 470         user_env[user_len - 1]       = '\0';
 471
 472         envp[0] = home_env;
 473         envp[1] = logname_env;
 474         envp[2] = mail_env;
 475         envp[3] = shell_env;
 476         envp[4] = user_env;
 477         envp[5] = 0;
 478
 479         if ((putenv(home_env)    < 0) ||
 480             (putenv(logname_env) < 0) ||
 481             (putenv(mail_env)    < 0) ||
 482             (putenv(shell_env)   < 0) ||
 483             (putenv(user_env)    < 0)) {
 484                 perror("vserver: putenv error ");
 485                 exit(1);
 486         }
 487 }
 488
 489 void slice_enter(char *context)
 490 {
 491         struct passwd pwdd, *pwd = &pwdd, *result;
 492         char          *pwdBuffer;
 493         long          pwdBuffer_len;
 494         unsigned remove_cap;
 495         uid_t uid;
 496
 497         pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 498         if (pwdBuffer_len == -1) {
 499                 perror("vserver: _SC_GETPW_R_SIZE_MAX not defined ");
 500                 exit(1);
 501         }
 502
 503         pwdBuffer = (char*)malloc(pwdBuffer_len);
 504         if (pwdBuffer == NULL) {
 505                 perror("vserver: malloc error ");
 506                 exit(1);
 507         }
 508
 509         errno = 0;
 510         if ((getpwnam_r(context,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 511                 fprintf(stderr,"vserver: getpwname(%s) failed",context);
 512                 perror("");
 513                 exit(2);
 514         }
 515
 516         context = (char*)malloc(strlen(pwd->pw_name)+NULLBYTE_SIZE);
 517         if (!context) {
 518                 perror("vserver: malloc failed");
 519                 exit(2);
 520         }
 521         strcpy(context,pwd->pw_name);
 522
 523         if (setuidgid_root() < 0) { /* For chroot, new_s_context */
 524                 fprintf(stderr,"vserver: Could not setuid/setguid to root:root\n");
 525                 exit(2);
 526         }
 527
 528         remove_cap = get_remove_cap(context);
 529
 530         uid = pwd->pw_uid;
 531         if (sandbox_chroot(uid) < 0) {
 532                 fprintf(stderr, "vserver: Could not chroot to vserver root\n");
 533                 exit(2);
 534         }
 535
 536         if (sandbox_processes(uid, remove_cap) < 0) {
 537                 fprintf(stderr, "vserver: Could not sandbox processes in vserver\n");
 538                 exit(2);
 539         }
 540 }
 541
 542 //--------------------------------------------------------------------
 543
 544 #define DEFAULT_SHELL "/bin/sh"
 545
 546 /* Exit statuses for programs like 'env' that exec other programs.
 547    EXIT_FAILURE might not be 1, so use EXIT_FAIL in such programs.  */
 548 enum
 549 {
 550   EXIT_CANNOT_INVOKE = 126,
 551   EXIT_ENOENT = 127
 552 };
 553
 554 int main(int argc, char **argv)
 555 {
 556     struct passwd   pwdd, *pwd = &pwdd, *result;
 557     char            *context, *username, *shell, *pwdBuffer;
 558     long            pwdBuffer_len;
 559     uid_t           uid;
 560     int             index, i;
 561
 562     if (argv[0][0]=='-')
 563       index = 1;
 564     else
 565       index = 0;
 566
 567     uid = getuid();
 568     if ((pwd = getpwuid(uid)) == NULL) {
 569       fprintf(stderr,"vsh: getpwnam error failed for %d\n",uid);
 570       exit(1);
 571     }
 572
 573     context = (char*)strdup(pwd->pw_name);
 574     if (!context) {
 575       perror("vsh: strdup failed");
 576       exit(2);
 577     }
 578
 579     /* enter vserver "context" */
 580     slice_enter(context);
 581
 582     /* Now run as username in this context. Note that for PlanetLab's
 583        vserver configuration the context name also happens to be the
 584        "default" username within the vserver context.
 585     */
 586     username = context;
 587     runas_slice_user(username);
 588
 589     /* With the uid/gid appropriately set. Let's figure out what the
 590      * shell in the vserver's /etc/passwd is for the given username.
 591      */
 592
 593     pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 594     if (pwdBuffer_len == -1) {
 595             perror("vserver: _SC_GETPW_R_SIZE_MAX not defined ");
 596             exit(1);
 597     }
 598     pwdBuffer = (char*)malloc(pwdBuffer_len);
 599     if (pwdBuffer == NULL) {
 600             perror("vserver: malloc error ");
 601             exit(1);
 602     }
 603
 604     errno = 0;
 605     if ((getpwnam_r(username,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 606         fprintf(stderr,"vsh: getpwnam error failed for %s\n",username);
 607         exit(1);
 608     }
 609
 610     /* Make sure pw->pw_shell is non-NULL.*/
 611     if (pwd->pw_shell == NULL || pwd->pw_shell[0] == '\0') {
 612       pwd->pw_shell = (char *) DEFAULT_SHELL;
 613     }
 614
 615     shell = (char *)strdup(pwd->pw_shell);
 616     if (!shell) {
 617       perror("vsh: strdup failed");
 618       exit(2);
 619     }
 620
 621     /* Check whether 'su' or 'sshd' invoked us as a login shell or
 622        not; did this above when testing argv[0]=='-'.
 623     */
 624     argv[0] = shell;
 625     if (index == 1) {
 626       char **args;
 627       args = (char**)malloc(sizeof(char*)*(argc+2));
 628       if (!args) {
 629         perror("vsh: malloc failed");
 630       }
 631       args[0] = argv[0];
 632       args[1] = "-l";
 633       for(i=1;i<argc+1;i++) {
 634         args[i+1] = argv[i];
 635       }
 636       argv = args;
 637     }
 638     (void) execvp(shell,argv);
 639     {
 640       int exit_status = (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 641       exit (exit_status);
 642     }
 643
 644     return 0; /* shutup compiler */
 645 }