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         unsigned long long *limit;
 209 };
 210
 211 #define VSERVERCONF "/etc/vservers/"
 212 static void get_limits(char *context, struct resources *list){
 213         FILE *fb;
 214         size_t len = strlen(VSERVERCONF) + strlen(context) + strlen(".conf") + NULLBYTE_SIZE;
 215         char *conf = (char *)malloc(len);
 216         struct resources *r;
 217
 218         sprintf(conf, "%s%s.conf", VSERVERCONF, context);
 219
 220         /* open the conf file for reading */
 221         fb = fopen(conf,"r");
 222         if (fb != NULL) {
 223                 size_t index;
 224                 char *buffer = malloc(1000);
 225                 char *p;
 226
 227                 /* the conf file exist */
 228                 while((p=fgets(buffer,1000-1,fb))!=NULL) {
 229                         index = 0;
 230                         len = strnlen(buffer,1000);
 231                         WHITESPACE(buffer,index,len);
 232                         if (buffer[index] == '#')
 233                                 continue;
 234
 235                         for (r=list; r->name; r++)
 236                                 if ((p=strstr(&buffer[index],r->name))!=NULL) {
 237                                         /* adjust index into buffer */
 238                                         index+= (p-&buffer[index])+strlen(r->name);
 239
 240                                         /* skip over whitespace */
 241                                         WHITESPACE(buffer,index,len);
 242
 243                                         /* expecting to see = sign */
 244                                         if (buffer[index++]!='=') goto out;
 245
 246                                         /* skip over whitespace */
 247                                         WHITESPACE(buffer,index,len);
 248
 249                                         /* expecting to see a digit for number */
 250                                         if (!isdigit((int)buffer[index])) goto out;
 251
 252                                         *r->limit = atoi(&buffer[index]);
 253                                         break;
 254                                 }
 255                 }
 256         out:
 257                 free(buffer);
 258         } else {
 259                 fprintf(stderr,"cannot open %s\n",conf);
 260         }
 261         free(conf);
 262 }
 263
 264
 265 static int sandbox_processes(xid_t xid, char *context)
 266 {
 267 #ifdef CONFIG_VSERVER_LEGACY
 268         int     flags;
 269
 270         flags = 0;
 271         flags |= 1; /* VX_INFO_LOCK -- cannot request a new vx_id */
 272         /* flags |= 4; VX_INFO_NPROC -- limit number of procs in a context */
 273
 274         (void) vc_new_s_context(xid, 0, flags);
 275
 276         /* use legacy dirty hack for capremove */
 277         if (vc_new_s_context(VC_SAMECTX, vc_get_insecurebcaps(), flags) == VC_NOCTX) {
 278                 PERROR("vc_new_s_context(%u, 0x%16ullx, 0x%08x)",
 279                        VC_SAMECTX, vc_get_insecurebcaps(), flags);
 280                 exit(1);
 281         }
 282 #else
 283         struct vc_rlimit limits;
 284         struct vc_ctx_caps caps;
 285         struct vc_ctx_flags flags;
 286
 287         xid_t ctx;
 288         unsigned long long cpu = VC_LIM_KEEP;
 289         unsigned long long mem = VC_LIM_KEEP;
 290         unsigned long long task = VC_LIM_KEEP;
 291         unsigned long long cpuguaranteed = 0;
 292         struct resources list[] =
 293                 {{"MEMLIMIT", &mem},
 294                  {"CPULIMIT", &cpu},
 295                  {"CPUGUARANTEED", &cpuguaranteed},
 296                  {"TASKLIMIT", &task},
 297                  {0,0}};
 298
 299         get_limits(context,list);
 300         (void) (sandbox_chroot(xid));
 301
 302         caps.ccaps = ~vc_get_insecureccaps();
 303         caps.cmask = ~0ull;
 304         caps.bcaps = ~vc_get_insecurebcaps();
 305         caps.bmask = ~0ull;
 306
 307         flags.flagword = VC_VXF_INFO_LOCK;
 308         flags.mask = VC_VXF_STATE_SETUP | VC_VXF_INFO_LOCK;
 309
 310         ctx = vc_ctx_create(xid);
 311         if (ctx == VC_NOCTX && errno != EEXIST) {
 312                 PERROR("vc_ctx_create(%d)", xid);
 313                 exit(1);
 314         }
 315
 316         /* CPU    */
 317         if (cpu != VC_LIM_KEEP) {
 318                 struct vc_set_sched sched = {
 319                         .set_mask = 0
 320                 };
 321
 322                 /* Need to distinguish between guarantee (hard) and
 323                  * best effort (share) from the vserver
 324                  * configuration.
 325                  */
 326 #define VC_VXF_SCHED_SHARE       0x00000800ull
 327                 flags.flagword |= VC_VXF_SCHED_HARD;
 328                 flags.mask |= VC_VXF_SCHED_HARD;
 329                 if (cpuguaranteed) {
 330                         flags.flagword |= VC_VXF_SCHED_SHARE;
 331                         flags.mask |= VC_VXF_SCHED_SHARE;
 332                 }
 333
 334                 /* CPULIMIT value from /etc/vservers/xyz.conf */
 335                 sched.fill_rate = cpu;
 336                 sched.set_mask |= VC_VXSM_FILL_RATE;
 337
 338                 sched.interval  = 1000; /* Andy's default value */
 339                 sched.set_mask |= VC_VXSM_INTERVAL;
 340
 341                 /* set base token value for new contexts */
 342                 if (ctx != VC_NOCTX) {
 343                         sched.tokens = 100; /* Andy's default value */
 344                         sched.set_mask |= VC_VXSM_TOKENS;
 345                 }
 346
 347                 sched.tokens_min = 50; /* Andy's default value */
 348                 sched.tokens_max = 100; /* Andy's default value */
 349                 sched.set_mask |= VC_VXSM_TOKENS_MIN;
 350                 sched.set_mask |= VC_VXSM_TOKENS_MAX;
 351
 352                 if (vc_set_sched(xid, &sched)==-1) {
 353                         PERROR("vc_set_sched()");
 354                         exit(1);
 355                 }
 356         }
 357
 358         /* MEM    */
 359         limits.min  = VC_LIM_KEEP;
 360         limits.soft = VC_LIM_KEEP;
 361         limits.hard = mem;
 362         if (vc_set_rlimit(xid, RLIMIT_RSS, &limits)) {
 363                 PERROR("vc_set_rlimit(%d, %d, %d/%d/%d)",
 364                        xid, RLIMIT_RSS, limits.min, limits.soft, limits.hard);
 365                 exit(1);
 366         }
 367
 368         /* TASK   */
 369         limits.min  = VC_LIM_KEEP;
 370         limits.soft = VC_LIM_KEEP;
 371         limits.hard = task;
 372         if (vc_set_rlimit(xid, RLIMIT_NPROC, &limits)) {
 373                 PERROR("vc_set_rlimit(%d, %d, %d/%d/%d)",
 374                        xid, RLIMIT_NPROC, limits.min, limits.soft, limits.hard);
 375                 exit(1);
 376         }
 377
 378         if (vc_set_ccaps(xid, &caps) == -1) {
 379                 PERROR("vc_set_ccaps(%d, 0x%16ullx/0x%16ullx, 0x%16ullx/0x%16ullx)",
 380                        xid, caps.ccaps, caps.cmask, caps.bcaps, caps.bmask);
 381                 exit(1);
 382         }
 383
 384         if (vc_set_cflags(xid, &flags) == -1) {
 385                 PERROR("vc_set_cflags(%d, 0x%16llx/0x%16llx)",
 386                        xid, flags.flagword, flags.mask);
 387                 exit(1);
 388         }
 389
 390         /* context already exists, migrate to it */
 391         if (ctx == VC_NOCTX && vc_ctx_migrate(xid) == -1) {
 392                 PERROR("vc_ctx_migrate(%d)", xid);
 393                 exit(1);
 394         }
 395 #endif
 396         return 0;
 397 }
 398
 399
 400 void runas_slice_user(char *username)
 401 {
 402         struct passwd pwdd, *pwd = &pwdd, *result;
 403         char          *pwdBuffer;
 404         char          *home_env, *logname_env, *mail_env, *shell_env, *user_env;
 405         int           home_len, logname_len, mail_len, shell_len, user_len;
 406         long          pwdBuffer_len;
 407         static char   *envp[10];
 408
 409
 410         pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 411         if (pwdBuffer_len == -1) {
 412                 PERROR("sysconf(_SC_GETPW_R_SIZE_MAX)");
 413                 exit(1);
 414         }
 415
 416         pwdBuffer = (char*)malloc(pwdBuffer_len);
 417         if (pwdBuffer == NULL) {
 418                 PERROR("malloc(%d)", pwdBuffer_len);
 419                 exit(1);
 420         }
 421
 422         errno = 0;
 423         if ((getpwnam_r(username,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 424                 PERROR("getpwnam_r(%s)", username);
 425                 exit(1);
 426         }
 427
 428         if (setgid(pwd->pw_gid) < 0) {
 429                 PERROR("setgid(%d)", pwd->pw_gid);
 430                 exit(1);
 431         }
 432
 433         if (setuid(pwd->pw_uid) < 0) {
 434                 PERROR("setuid(%d)", pwd->pw_uid);
 435                 exit(1);
 436         }
 437
 438         if (chdir(pwd->pw_dir) < 0) {
 439                 PERROR("chdir(%s)", pwd->pw_dir);
 440                 exit(1);
 441         }
 442
 443         home_len    = strlen("HOME=") + strlen(pwd->pw_dir) + NULLBYTE_SIZE;
 444         logname_len = strlen("LOGNAME=") + strlen(username) + NULLBYTE_SIZE;
 445         mail_len    = strlen("MAIL=/var/spool/mail/") + strlen(username)
 446                 + NULLBYTE_SIZE;
 447         shell_len   = strlen("SHELL=") + strlen(pwd->pw_shell) + NULLBYTE_SIZE;
 448         user_len    = strlen("USER=") + strlen(username) + NULLBYTE_SIZE;
 449
 450         home_env    = (char *)malloc(home_len);
 451         logname_env = (char *)malloc(logname_len);
 452         mail_env    = (char *)malloc(mail_len);
 453         shell_env   = (char *)malloc(shell_len);
 454         user_env    = (char *)malloc(user_len);
 455
 456         if ((home_env    == NULL)  ||
 457             (logname_env == NULL)  ||
 458             (mail_env    == NULL)  ||
 459             (shell_env   == NULL)  ||
 460             (user_env    == NULL)) {
 461                 PERROR("malloc");
 462                 exit(1);
 463         }
 464
 465         sprintf(home_env, "HOME=%s", pwd->pw_dir);
 466         sprintf(logname_env, "LOGNAME=%s", username);
 467         sprintf(mail_env, "MAIL=/var/spool/mail/%s", username);
 468         sprintf(shell_env, "SHELL=%s", pwd->pw_shell);
 469         sprintf(user_env, "USER=%s", username);
 470
 471         home_env[home_len - 1]       = '\0';
 472         logname_env[logname_len - 1] = '\0';
 473         mail_env[mail_len - 1]       = '\0';
 474         shell_env[shell_len - 1]     = '\0';
 475         user_env[user_len - 1]       = '\0';
 476
 477         envp[0] = home_env;
 478         envp[1] = logname_env;
 479         envp[2] = mail_env;
 480         envp[3] = shell_env;
 481         envp[4] = user_env;
 482         envp[5] = 0;
 483
 484         if ((putenv(home_env)    < 0) ||
 485             (putenv(logname_env) < 0) ||
 486             (putenv(mail_env)    < 0) ||
 487             (putenv(shell_env)   < 0) ||
 488             (putenv(user_env)    < 0)) {
 489                 PERROR("vserver: putenv error ");
 490                 exit(1);
 491         }
 492 }
 493
 494 void slice_enter(char *context)
 495 {
 496         struct passwd pwdd, *pwd = &pwdd, *result;
 497         char          *pwdBuffer;
 498         long          pwdBuffer_len;
 499         uid_t uid;
 500
 501         pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 502         if (pwdBuffer_len == -1) {
 503                 PERROR("sysconf(_SC_GETPW_R_SIZE_MAX)");
 504                 exit(1);
 505         }
 506
 507         pwdBuffer = (char*)malloc(pwdBuffer_len);
 508         if (pwdBuffer == NULL) {
 509                 PERROR("malloc(%d)", pwdBuffer_len);
 510                 exit(1);
 511         }
 512
 513         errno = 0;
 514         if ((getpwnam_r(context,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 515                 PERROR("getpwnam_r(%s)", context);
 516                 exit(2);
 517         }
 518         uid = pwd->pw_uid;
 519
 520         if (setuidgid_root() < 0) { /* For chroot, new_s_context */
 521                 fprintf(stderr, "vsh: Could not become root, check that SUID flag is set on binary\n");
 522                 exit(2);
 523         }
 524
 525 #ifdef CONFIG_VSERVER_LEGACY
 526         (void) (sandbox_chroot(uid));
 527 #endif
 528
 529         if (sandbox_processes((xid_t) uid, context) < 0) {
 530                 fprintf(stderr, "vsh: Could not change context to %d\n", uid);
 531                 exit(2);
 532         }
 533 }
 534
 535 //--------------------------------------------------------------------
 536
 537 #define DEFAULT_SHELL "/bin/sh"
 538
 539 /* Exit statuses for programs like 'env' that exec other programs.
 540    EXIT_FAILURE might not be 1, so use EXIT_FAIL in such programs.  */
 541 enum
 542 {
 543   EXIT_CANNOT_INVOKE = 126,
 544   EXIT_ENOENT = 127
 545 };
 546
 547 int main(int argc, char **argv)
 548 {
 549     struct passwd   pwdd, *pwd = &pwdd, *result;
 550     char            *context, *username, *shell, *pwdBuffer;
 551     long            pwdBuffer_len;
 552     uid_t           uid;
 553     int             index, i;
 554
 555     if (argv[0][0]=='-')
 556       index = 1;
 557     else
 558       index = 0;
 559
 560     uid = getuid();
 561     if ((pwd = getpwuid(uid)) == NULL) {
 562       PERROR("getpwuid(%d)", uid);
 563       exit(1);
 564     }
 565
 566     context = (char*)strdup(pwd->pw_name);
 567     if (!context) {
 568       PERROR("strdup");
 569       exit(2);
 570     }
 571
 572     /* enter vserver "context" */
 573     slice_enter(context);
 574
 575     /* Now run as username in this context. Note that for PlanetLab's
 576        vserver configuration the context name also happens to be the
 577        "default" username within the vserver context.
 578     */
 579     username = context;
 580     runas_slice_user(username);
 581
 582     /* With the uid/gid appropriately set. Let's figure out what the
 583      * shell in the vserver's /etc/passwd is for the given username.
 584      */
 585
 586     pwdBuffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 587     if (pwdBuffer_len == -1) {
 588             PERROR("sysconf(_SC_GETPW_R_SIZE_MAX");
 589             exit(1);
 590     }
 591     pwdBuffer = (char*)malloc(pwdBuffer_len);
 592     if (pwdBuffer == NULL) {
 593             PERROR("malloc(%d)", pwdBuffer_len);
 594             exit(1);
 595     }
 596
 597     errno = 0;
 598     if ((getpwnam_r(username,pwd,pwdBuffer,pwdBuffer_len, &result) != 0) || (errno != 0)) {
 599         PERROR("getpwnam_r(%s)", username);
 600         exit(1);
 601     }
 602
 603     /* Make sure pw->pw_shell is non-NULL.*/
 604     if (pwd->pw_shell == NULL || pwd->pw_shell[0] == '\0') {
 605       pwd->pw_shell = (char *) DEFAULT_SHELL;
 606     }
 607
 608     shell = (char *)strdup(pwd->pw_shell);
 609     if (!shell) {
 610       PERROR("strdup");
 611       exit(2);
 612     }
 613
 614     /* Check whether 'su' or 'sshd' invoked us as a login shell or
 615        not; did this above when testing argv[0]=='-'.
 616     */
 617     argv[0] = shell;
 618     if (index == 1) {
 619       char **args;
 620       args = (char**)malloc(sizeof(char*)*(argc+2));
 621       if (!args) {
 622         PERROR("malloc(%d)", sizeof(char*)*(argc+2));
 623         exit(1);
 624       }
 625       args[0] = argv[0];
 626       args[1] = "-l";
 627       for(i=1;i<argc+1;i++) {
 628         args[i+1] = argv[i];
 629       }
 630       argv = args;
 631     }
 632     (void) execvp(shell,argv);
 633     {
 634       int exit_status = (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 635       exit (exit_status);
 636     }
 637
 638     return 0; /* shutup compiler */
 639 }