git.gag.com Git - debian/sudo/blob - env.c

   1 /*
   2  * Copyright (c) 2000-2005, 2007-2009
   3  *      Todd C. Miller <Todd.Miller@courtesan.com>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  *
  17  * Sponsored in part by the Defense Advanced Research Projects
  18  * Agency (DARPA) and Air Force Research Laboratory, Air Force
  19  * Materiel Command, USAF, under agreement number F39502-99-1-0512.
  20  */
  21
  22 #include <config.h>
  23
  24 #include <sys/types.h>
  25 #include <sys/param.h>
  26 #include <sys/stat.h>
  27 #include <stdio.h>
  28 #ifdef STDC_HEADERS
  29 # include <stdlib.h>
  30 # include <stddef.h>
  31 #else
  32 # ifdef HAVE_STDLIB_H
  33 #  include <stdlib.h>
  34 # endif
  35 #endif /* STDC_HEADERS */
  36 #ifdef HAVE_STRING_H
  37 # include <string.h>
  38 #else
  39 # ifdef HAVE_STRINGS_H
  40 #  include <strings.h>
  41 # endif
  42 #endif /* HAVE_STRING_H */
  43 #ifdef HAVE_UNISTD_H
  44 # include <unistd.h>
  45 #endif /* HAVE_UNISTD_H */
  46 #include <ctype.h>
  47 #include <errno.h>
  48 #include <pwd.h>
  49
  50 #include "sudo.h"
  51
  52 /*
  53  * Flags used in rebuild_env()
  54  */
  55 #undef DID_TERM
  56 #define DID_TERM        0x0001
  57 #undef DID_PATH
  58 #define DID_PATH        0x0002
  59 #undef DID_HOME
  60 #define DID_HOME        0x0004
  61 #undef DID_SHELL
  62 #define DID_SHELL       0x0008
  63 #undef DID_LOGNAME
  64 #define DID_LOGNAME     0x0010
  65 #undef DID_USER
  66 #define DID_USER        0x0020
  67 #undef DID_USERNAME
  68 #define DID_USERNAME    0x0040
  69 #undef DID_MAX
  70 #define DID_MAX         0x00ff
  71
  72 #undef KEPT_TERM
  73 #define KEPT_TERM       0x0100
  74 #undef KEPT_PATH
  75 #define KEPT_PATH       0x0200
  76 #undef KEPT_HOME
  77 #define KEPT_HOME       0x0400
  78 #undef KEPT_SHELL
  79 #define KEPT_SHELL      0x0800
  80 #undef KEPT_LOGNAME
  81 #define KEPT_LOGNAME    0x1000
  82 #undef KEPT_USER
  83 #define KEPT_USER       0x2000
  84 #undef KEPT_USERNAME
  85 #define KEPT_USERNAME   0x4000
  86 #undef KEPT_MAX
  87 #define KEPT_MAX        0xff00
  88
  89 #undef VNULL
  90 #define VNULL   (void *)NULL
  91
  92 struct environment {
  93     char **envp;                /* pointer to the new environment */
  94     size_t env_size;            /* size of new_environ in char **'s */
  95     size_t env_len;             /* number of slots used, not counting NULL */
  96 };
  97
  98 /*
  99  * Prototypes
 100  */
 101 void rebuild_env                __P((int, int));
 102 static void sudo_setenv         __P((const char *, const char *, int));
 103 static void sudo_putenv         __P((char *, int, int));
 104
 105 extern char **environ;          /* global environment */
 106
 107 /*
 108  * Copy of the sudo-managed environment.
 109  */
 110 static struct environment env;
 111
 112 /*
 113  * Default table of "bad" variables to remove from the environment.
 114  * XXX - how to omit TERMCAP if it starts with '/'?
 115  */
 116 static const char *initial_badenv_table[] = {
 117     "IFS",
 118     "CDPATH",
 119     "LOCALDOMAIN",
 120     "RES_OPTIONS",
 121     "HOSTALIASES",
 122     "NLSPATH",
 123     "PATH_LOCALE",
 124     "LD_*",
 125     "_RLD*",
 126 #ifdef __hpux
 127     "SHLIB_PATH",
 128 #endif /* __hpux */
 129 #ifdef _AIX
 130     "LDR_*",
 131     "LIBPATH",
 132     "AUTHSTATE",
 133 #endif
 134 #ifdef __APPLE__
 135     "DYLD_*",
 136 #endif
 137 #ifdef HAVE_KERB4
 138     "KRB_CONF*",
 139     "KRBCONFDIR",
 140     "KRBTKFILE",
 141 #endif /* HAVE_KERB4 */
 142 #ifdef HAVE_KERB5
 143     "KRB5_CONFIG*",
 144     "KRB5_KTNAME",
 145 #endif /* HAVE_KERB5 */
 146 #ifdef HAVE_SECURID
 147     "VAR_ACE",
 148     "USR_ACE",
 149     "DLC_ACE",
 150 #endif /* HAVE_SECURID */
 151     "TERMINFO",                 /* terminfo, exclusive path to terminfo files */
 152     "TERMINFO_DIRS",            /* terminfo, path(s) to terminfo files */
 153     "TERMPATH",                 /* termcap, path(s) to termcap files */
 154     "TERMCAP",                  /* XXX - only if it starts with '/' */
 155     "ENV",                      /* ksh, file to source before script runs */
 156     "BASH_ENV",                 /* bash, file to source before script runs */
 157     "PS4",                      /* bash, prefix for lines in xtrace mode */
 158     "GLOBIGNORE",               /* bash, globbing patterns to ignore */
 159     "SHELLOPTS",                /* bash, extra command line options */
 160     "JAVA_TOOL_OPTIONS",        /* java, extra command line options */
 161     "PERLIO_DEBUG ",            /* perl, debugging output file */
 162     "PERLLIB",                  /* perl, search path for modules/includes */
 163     "PERL5LIB",                 /* perl 5, search path for modules/includes */
 164     "PERL5OPT",                 /* perl 5, extra command line options */
 165     "PERL5DB",                  /* perl 5, command used to load debugger */
 166     "FPATH",                    /* ksh, search path for functions */
 167     "NULLCMD",                  /* zsh, command for null file redirection */
 168     "READNULLCMD",              /* zsh, command for null file redirection */
 169     "ZDOTDIR",                  /* zsh, search path for dot files */
 170     "TMPPREFIX",                /* zsh, prefix for temporary files */
 171     "PYTHONHOME",               /* python, module search path */
 172     "PYTHONPATH",               /* python, search path */
 173     "PYTHONINSPECT",            /* python, allow inspection */
 174     "RUBYLIB",                  /* ruby, library load path */
 175     "RUBYOPT",                  /* ruby, extra command line options */
 176     NULL
 177 };
 178
 179 /*
 180  * Default table of variables to check for '%' and '/' characters.
 181  */
 182 static const char *initial_checkenv_table[] = {
 183     "COLORTERM",
 184     "LANG",
 185     "LANGUAGE",
 186     "LC_*",
 187     "LINGUAS",
 188     "TERM",
 189     NULL
 190 };
 191
 192 /*
 193  * Default table of variables to preserve in the environment.
 194  */
 195 static const char *initial_keepenv_table[] = {
 196     "COLORS",
 197     "DISPLAY",
 198     "HOME",
 199     "HOSTNAME",
 200     "KRB5CCNAME",
 201     "LS_COLORS",
 202     "MAIL",
 203     "PATH",
 204     "PS1",
 205     "PS2",
 206     "TZ",
 207     "XAUTHORITY",
 208     "XAUTHORIZATION",
 209     NULL
 210 };
 211
 212 /*
 213  * Similar to setenv(3) but operates on sudo's private copy of the environment
 214  * (not environ) and it always overwrites.  The dupcheck param determines
 215  * whether we need to verify that the variable is not already set.
 216  */
 217 static void
 218 sudo_setenv(var, val, dupcheck)
 219     const char *var;
 220     const char *val;
 221     int dupcheck;
 222 {
 223     char *estring;
 224     size_t esize;
 225
 226     esize = strlen(var) + 1 + strlen(val) + 1;
 227     estring = emalloc(esize);
 228
 229     /* Build environment string and insert it. */
 230     if (strlcpy(estring, var, esize) >= esize ||
 231         strlcat(estring, "=", esize) >= esize ||
 232         strlcat(estring, val, esize) >= esize) {
 233
 234         errorx(1, "internal error, sudo_setenv() overflow");
 235     }
 236     sudo_putenv(estring, dupcheck, TRUE);
 237 }
 238
 239 /*
 240  * Version of setenv(3) that uses our own environ pointer.
 241  * Will sync with environ as needed.
 242  */
 243 int
 244 setenv(var, val, overwrite)
 245     const char *var;
 246     const char *val;
 247     int overwrite;
 248 {
 249     char *estring, *ep;
 250     const char *cp;
 251     size_t esize;
 252
 253     if (!var || *var == '\0')
 254         return(EINVAL);
 255
 256     /*
 257      * POSIX says a var name with '=' is an error but BSD
 258      * just ignores the '=' and anything after it.
 259      */
 260     for (cp = var; *cp && *cp != '='; cp++)
 261         ;
 262     esize = (size_t)(cp - var) + 2;
 263     if (val) {
 264         esize += strlen(val);   /* glibc treats a NULL val as "" */
 265     }
 266
 267     /* Allocate and fill in estring. */
 268     estring = ep = emalloc(esize);
 269     for (cp = var; *cp && *cp != '='; cp++)
 270         *ep++ = *cp;
 271     *ep++ = '=';
 272     if (val) {
 273         for (cp = val; *cp; cp++)
 274             *ep++ = *cp;
 275     }
 276     *ep = '\0';
 277
 278     /* Sync env.envp with environ as needed. */
 279     if (env.envp != environ) {
 280         char **ep;
 281         size_t len;
 282
 283         for (ep = environ; *ep != NULL; ep++)
 284             continue;
 285         len = ep - environ;
 286         if (len + 2 > env.env_size) {
 287             efree(env.envp);
 288             env.env_size = len + 2 + 128;
 289             env.envp = emalloc2(env.env_size, sizeof(char *));
 290 #ifdef ENV_DEBUG
 291             memset(env.envp, 0, env.env_size * sizeof(char *));
 292 #endif
 293         }
 294         memcpy(env.envp, environ, len * sizeof(char *));
 295         env.envp[len] = NULL;
 296         env.env_len = len;
 297         environ = env.envp;
 298 #ifdef ENV_DEBUG
 299     } else {
 300         if (env.envp[env.env_len] != NULL)
 301             errorx(1, "setenv: corrupted envp, len mismatch");
 302 #endif
 303     }
 304     sudo_putenv(estring, TRUE, overwrite);
 305     return(0);
 306 }
 307
 308 /*
 309  * Version of unsetenv(3) that uses our own environ pointer.
 310  * Will sync with environ as needed.
 311  */
 312 #ifdef UNSETENV_VOID
 313 void
 314 #else
 315 int
 316 #endif
 317 unsetenv(var)
 318     const char *var;
 319 {
 320     char **ep = env.envp;
 321     size_t len;
 322
 323     if (strchr(var, '=') != NULL) {
 324         errno = EINVAL;
 325 #ifdef UNSETENV_VOID
 326         return;
 327 #else
 328         return(-1);
 329 #endif
 330     }
 331
 332     /* Make sure we are operating on the current environment. */
 333     /* XXX - this could be optimized to include the search */
 334     if (env.envp != environ) {
 335         for (ep = environ; *ep != NULL; ep++)
 336             continue;
 337         len = ep - environ;
 338         if (len + 1 > env.env_size) {
 339             efree(env.envp);
 340             env.env_size = len + 1 + 128;
 341             env.envp = emalloc2(env.env_size, sizeof(char *));
 342 #ifdef ENV_DEBUG
 343             memset(env.envp, 0, env.env_size * sizeof(char *));
 344 #endif
 345         }
 346         memcpy(env.envp, environ, len * sizeof(char *));
 347         env.envp[len] = NULL;
 348         env.env_len = len;
 349         environ = env.envp;
 350 #ifdef ENV_DEBUG
 351     } else {
 352         if (env.envp[env.env_len] != NULL)
 353             errorx(1, "unsetenv: corrupted envp, len mismatch");
 354 #endif
 355     }
 356
 357     len = strlen(var);
 358     while (*ep != NULL) {
 359         if (strncmp(var, *ep, len) == 0 && (*ep)[len] == '=') {
 360             /* Found it; shift remainder + NULL over by one and update len. */
 361             memmove(ep, ep + 1,
 362                 (env.env_len - (ep - env.envp)) * sizeof(char *));
 363             env.env_len--;
 364             /* Keep going, could be multiple instances of the var. */
 365         } else {
 366             ep++;
 367         }
 368     }
 369 #ifndef UNSETENV_VOID
 370     return(0);
 371 #endif
 372 }
 373
 374 /*
 375  * Version of putenv(3) that uses our own environ pointer.
 376  * Will sync with environ as needed.
 377  */
 378 int
 379 #ifdef PUTENV_CONST
 380 putenv(const char *string)
 381 #else
 382 putenv(string)
 383     char *string;
 384 #endif
 385 {
 386     if (strchr(string, '=') == NULL) {
 387         errno = EINVAL;
 388         return(-1);
 389     }
 390     /* Sync env.envp with environ as needed. */
 391     if (env.envp != environ) {
 392         char **ep;
 393         size_t len;
 394
 395         for (ep = environ; *ep != NULL; ep++)
 396             continue;
 397         len = ep - environ;
 398         if (len + 2 > env.env_size) {
 399             efree(env.envp);
 400             env.env_size = len + 2 + 128;
 401             env.envp = emalloc2(env.env_size, sizeof(char *));
 402 #ifdef ENV_DEBUG
 403             memset(env.envp, 0, env.env_size * sizeof(char *));
 404 #endif
 405         }
 406         memcpy(env.envp, environ, len * sizeof(char *));
 407         env.envp[len] = NULL;
 408         env.env_len = len;
 409         environ = env.envp;
 410 #ifdef ENV_DEBUG
 411     } else {
 412         if (env.envp[env.env_len] != NULL)
 413             errorx(1, "putenv: corrupted envp, len mismatch");
 414 #endif
 415     }
 416     sudo_putenv((char *)string, TRUE, TRUE);
 417     return(0);
 418 }
 419
 420 /*
 421  * Similar to putenv(3) but operates on sudo's private copy of the
 422  * environment (not environ) and it always overwrites.  The dupcheck param
 423  * determines whether we need to verify that the variable is not already set.
 424  * Will only overwrite an existing variable if overwrite is set.
 425  */
 426 static void
 427 sudo_putenv(str, dupcheck, overwrite)
 428     char *str;
 429     int dupcheck;
 430     int overwrite;
 431 {
 432     char **ep;
 433     size_t len;
 434     int found = FALSE;
 435
 436     /* Make sure there is room for the new entry plus a NULL. */
 437     if (env.env_len + 2 > env.env_size) {
 438         env.env_size += 128;
 439         env.envp = erealloc3(env.envp, env.env_size, sizeof(char *));
 440 #ifdef ENV_DEBUG
 441         memset(env.envp + env.env_len, 0,
 442             (env.env_size - env.env_len) * sizeof(char *));
 443 #endif
 444         environ = env.envp;
 445     }
 446
 447 #ifdef ENV_DEBUG
 448     if (env.envp[env.env_len] != NULL)
 449         errorx(1, "sudo_putenv: corrupted envp, len mismatch");
 450 #endif
 451
 452     if (dupcheck) {
 453         len = (strchr(str, '=') - str) + 1;
 454         for (ep = env.envp; !found && *ep != NULL; ep++) {
 455             if (strncmp(str, *ep, len) == 0) {
 456                 if (overwrite)
 457                     *ep = str;
 458                 found = TRUE;
 459             }
 460         }
 461         /* Prune out duplicate variables. */
 462         if (found && overwrite) {
 463             while (*ep != NULL) {
 464                 if (strncmp(str, *ep, len) == 0) {
 465                     memmove(ep, ep + 1,
 466                         (env.env_len - (ep - env.envp)) * sizeof(char *));
 467                     env.env_len--;
 468                 } else {
 469                     ep++;
 470                 }
 471             }
 472         }
 473     }
 474
 475     if (!found) {
 476         ep = env.envp + env.env_len;
 477         env.env_len++;
 478         *ep++ = str;
 479         *ep = NULL;
 480     }
 481 }
 482
 483 /*
 484  * Check the env_delete blacklist.
 485  * Returns TRUE if the variable was found, else false.
 486  */
 487 static int
 488 matches_env_delete(var)
 489     const char *var;
 490 {
 491     struct list_member *cur;
 492     size_t len;
 493     int iswild, match = FALSE;
 494
 495     /* Skip anything listed in env_delete. */
 496     for (cur = def_env_delete; cur; cur = cur->next) {
 497         len = strlen(cur->value);
 498         /* Deal with '*' wildcard */
 499         if (cur->value[len - 1] == '*') {
 500             len--;
 501             iswild = TRUE;
 502         } else
 503             iswild = FALSE;
 504         if (strncmp(cur->value, var, len) == 0 &&
 505             (iswild || var[len] == '=')) {
 506             match = TRUE;
 507             break;
 508         }
 509     }
 510     return(match);
 511 }
 512
 513 /*
 514  * Apply the env_check list.
 515  * Returns TRUE if the variable is allowed, FALSE if denied
 516  * or -1 if no match.
 517  */
 518 static int
 519 matches_env_check(var)
 520     const char *var;
 521 {
 522     struct list_member *cur;
 523     size_t len;
 524     int iswild, keepit = -1;
 525
 526     for (cur = def_env_check; cur; cur = cur->next) {
 527         len = strlen(cur->value);
 528         /* Deal with '*' wildcard */
 529         if (cur->value[len - 1] == '*') {
 530             len--;
 531             iswild = TRUE;
 532         } else
 533             iswild = FALSE;
 534         if (strncmp(cur->value, var, len) == 0 &&
 535             (iswild || var[len] == '=')) {
 536             keepit = !strpbrk(var, "/%");
 537             break;
 538         }
 539     }
 540     return(keepit);
 541 }
 542
 543 /*
 544  * Check the env_keep list.
 545  * Returns TRUE if the variable is allowed else FALSE.
 546  */
 547 static int
 548 matches_env_keep(var)
 549     const char *var;
 550 {
 551     struct list_member *cur;
 552     size_t len;
 553     int iswild, keepit = FALSE;
 554
 555     for (cur = def_env_keep; cur; cur = cur->next) {
 556         len = strlen(cur->value);
 557         /* Deal with '*' wildcard */
 558         if (cur->value[len - 1] == '*') {
 559             len--;
 560             iswild = TRUE;
 561         } else
 562             iswild = FALSE;
 563         if (strncmp(cur->value, var, len) == 0 &&
 564             (iswild || var[len] == '=')) {
 565             keepit = TRUE;
 566             break;
 567         }
 568     }
 569     return(keepit);
 570 }
 571
 572 /*
 573  * Build a new environment and ether clear potentially dangerous
 574  * variables from the old one or start with a clean slate.
 575  * Also adds sudo-specific variables (SUDO_*).
 576  */
 577 void
 578 rebuild_env(sudo_mode, noexec)
 579     int sudo_mode;
 580     int noexec;
 581 {
 582     char **old_envp, **ep, *cp, *ps1;
 583     char idbuf[MAX_UID_T_LEN];
 584     unsigned int didvar;
 585
 586     /*
 587      * Either clean out the environment or reset to a safe default.
 588      */
 589     ps1 = NULL;
 590     didvar = 0;
 591     env.env_len = 0;
 592     env.env_size = 128;
 593     old_envp = env.envp;
 594     env.envp = emalloc2(env.env_size, sizeof(char *));
 595 #ifdef ENV_DEBUG
 596     memset(env.envp, 0, env.env_size * sizeof(char *));
 597 #endif
 598     if (def_env_reset || ISSET(sudo_mode, MODE_LOGIN_SHELL)) {
 599         /* Pull in vars we want to keep from the old environment. */
 600         for (ep = environ; *ep; ep++) {
 601             int keepit;
 602
 603             /* Skip variables with values beginning with () (bash functions) */
 604             if ((cp = strchr(*ep, '=')) != NULL) {
 605                 if (strncmp(cp, "=() ", 3) == 0)
 606                     continue;
 607             }
 608
 609             /*
 610              * First check certain variables for '%' and '/' characters.
 611              * If no match there, check the keep list.
 612              * If nothing matched, we remove it from the environment.
 613              */
 614             keepit = matches_env_check(*ep);
 615             if (keepit == -1)
 616                 keepit = matches_env_keep(*ep);
 617
 618             /* For SUDO_PS1 -> PS1 conversion. */
 619             if (strncmp(*ep, "SUDO_PS1=", 8) == 0)
 620                 ps1 = *ep + 5;
 621
 622             if (keepit) {
 623                 /* Preserve variable. */
 624                 switch (**ep) {
 625                     case 'H':
 626                         if (strncmp(*ep, "HOME=", 5) == 0)
 627                             SET(didvar, DID_HOME);
 628                         break;
 629                     case 'L':
 630                         if (strncmp(*ep, "LOGNAME=", 8) == 0)
 631                             SET(didvar, DID_LOGNAME);
 632                         break;
 633                     case 'P':
 634                         if (strncmp(*ep, "PATH=", 5) == 0)
 635                             SET(didvar, DID_PATH);
 636                         break;
 637                     case 'S':
 638                         if (strncmp(*ep, "SHELL=", 6) == 0)
 639                             SET(didvar, DID_SHELL);
 640                         break;
 641                     case 'T':
 642                         if (strncmp(*ep, "TERM=", 5) == 0)
 643                             SET(didvar, DID_TERM);
 644                         break;
 645                     case 'U':
 646                         if (strncmp(*ep, "USER=", 5) == 0)
 647                             SET(didvar, DID_USER);
 648                         if (strncmp(*ep, "USERNAME=", 5) == 0)
 649                             SET(didvar, DID_USERNAME);
 650                         break;
 651                 }
 652                 sudo_putenv(*ep, FALSE, FALSE);
 653             }
 654         }
 655         didvar |= didvar << 8;          /* convert DID_* to KEPT_* */
 656
 657         /*
 658          * Add in defaults.  In -i mode these come from the runas user,
 659          * otherwise they may be from the user's environment (depends
 660          * on sudoers options).
 661          */
 662         if (ISSET(sudo_mode, MODE_LOGIN_SHELL)) {
 663             sudo_setenv("HOME", runas_pw->pw_dir, ISSET(didvar, DID_HOME));
 664             sudo_setenv("SHELL", runas_pw->pw_shell, ISSET(didvar, DID_SHELL));
 665             sudo_setenv("LOGNAME", runas_pw->pw_name,
 666                 ISSET(didvar, DID_LOGNAME));
 667             sudo_setenv("USER", runas_pw->pw_name, ISSET(didvar, DID_USER));
 668             sudo_setenv("USERNAME", runas_pw->pw_name,
 669                 ISSET(didvar, DID_USERNAME));
 670         } else {
 671             if (!ISSET(didvar, DID_HOME))
 672                 sudo_setenv("HOME", user_dir, FALSE);
 673             if (!ISSET(didvar, DID_SHELL))
 674                 sudo_setenv("SHELL", sudo_user.pw->pw_shell, FALSE);
 675             if (!ISSET(didvar, DID_LOGNAME))
 676                 sudo_setenv("LOGNAME", user_name, FALSE);
 677             if (!ISSET(didvar, DID_USER))
 678                 sudo_setenv("USER", user_name, FALSE);
 679             if (!ISSET(didvar, DID_USERNAME))
 680                 sudo_setenv("USERNAME", user_name, FALSE);
 681         }
 682     } else {
 683         /*
 684          * Copy environ entries as long as they don't match env_delete or
 685          * env_check.
 686          */
 687         for (ep = environ; *ep; ep++) {
 688             int okvar;
 689
 690             /* Skip variables with values beginning with () (bash functions) */
 691             if ((cp = strchr(*ep, '=')) != NULL) {
 692                 if (strncmp(cp, "=() ", 3) == 0)
 693                     continue;
 694             }
 695
 696             /*
 697              * First check variables against the blacklist in env_delete.
 698              * If no match there check for '%' and '/' characters.
 699              */
 700             okvar = matches_env_delete(*ep) != TRUE;
 701             if (okvar)
 702                 okvar = matches_env_check(*ep) != FALSE;
 703
 704             if (okvar) {
 705                 if (strncmp(*ep, "SUDO_PS1=", 9) == 0)
 706                     ps1 = *ep + 5;
 707                 else if (strncmp(*ep, "PATH=", 5) == 0)
 708                     SET(didvar, DID_PATH);
 709                 else if (strncmp(*ep, "TERM=", 5) == 0)
 710                     SET(didvar, DID_TERM);
 711                 sudo_putenv(*ep, FALSE, FALSE);
 712             }
 713         }
 714     }
 715     /* Replace the PATH envariable with a secure one? */
 716     if (def_secure_path && !user_is_exempt()) {
 717         sudo_setenv("PATH", def_secure_path, TRUE);
 718         SET(didvar, DID_PATH);
 719     }
 720
 721     /* Set $USER, $LOGNAME and $USERNAME to target if "set_logname" is true. */
 722     /* XXX - not needed for MODE_LOGIN_SHELL */
 723     if (def_set_logname && runas_pw->pw_name) {
 724         if (!ISSET(didvar, KEPT_LOGNAME))
 725             sudo_setenv("LOGNAME", runas_pw->pw_name, TRUE);
 726         if (!ISSET(didvar, KEPT_USER))
 727             sudo_setenv("USER", runas_pw->pw_name, TRUE);
 728         if (!ISSET(didvar, KEPT_USERNAME))
 729             sudo_setenv("USERNAME", runas_pw->pw_name, TRUE);
 730     }
 731
 732     /* Set $HOME for `sudo -H'.  Only valid at PERM_FULL_RUNAS. */
 733     /* XXX - not needed for MODE_LOGIN_SHELL */
 734     if (runas_pw->pw_dir) {
 735         if (ISSET(sudo_mode, MODE_RESET_HOME) ||
 736             (ISSET(sudo_mode, MODE_RUN) && (def_always_set_home ||
 737             (ISSET(sudo_mode, MODE_SHELL) && def_set_home))))
 738             sudo_setenv("HOME", runas_pw->pw_dir, TRUE);
 739     }
 740
 741     /* Provide default values for $TERM and $PATH if they are not set. */
 742     if (!ISSET(didvar, DID_TERM))
 743         sudo_putenv("TERM=unknown", FALSE, FALSE);
 744     if (!ISSET(didvar, DID_PATH))
 745         sudo_setenv("PATH", _PATH_DEFPATH, FALSE);
 746
 747     /*
 748      * Preload a noexec file?  For a list of LD_PRELOAD-alikes, see
 749      * http://www.fortran-2000.com/ArnaudRecipes/sharedlib.html
 750      * XXX - should prepend to original value, if any
 751      */
 752     if (noexec && def_noexec_file != NULL) {
 753 #if defined(__darwin__) || defined(__APPLE__)
 754         sudo_setenv("DYLD_INSERT_LIBRARIES", def_noexec_file, TRUE);
 755         sudo_setenv("DYLD_FORCE_FLAT_NAMESPACE", "", TRUE);
 756 #else
 757 # if defined(__osf__) || defined(__sgi)
 758         easprintf(&cp, "%s:DEFAULT", def_noexec_file);
 759         sudo_setenv("_RLD_LIST", cp, TRUE);
 760         efree(cp);
 761 # else
 762 #  ifdef _AIX
 763         sudo_setenv("LDR_PRELOAD", def_noexec_file, TRUE);
 764 #  else
 765         sudo_setenv("LD_PRELOAD", def_noexec_file, TRUE);
 766 #  endif /* _AIX */
 767 # endif /* __osf__ || __sgi */
 768 #endif /* __darwin__ || __APPLE__ */
 769     }
 770
 771     /* Set PS1 if SUDO_PS1 is set. */
 772     if (ps1 != NULL)
 773         sudo_putenv(ps1, TRUE, TRUE);
 774
 775     /* Add the SUDO_COMMAND envariable (cmnd + args). */
 776     if (user_args) {
 777         easprintf(&cp, "%s %s", user_cmnd, user_args);
 778         sudo_setenv("SUDO_COMMAND", cp, TRUE);
 779         efree(cp);
 780     } else
 781         sudo_setenv("SUDO_COMMAND", user_cmnd, TRUE);
 782
 783     /* Add the SUDO_USER, SUDO_UID, SUDO_GID environment variables. */
 784     sudo_setenv("SUDO_USER", user_name, TRUE);
 785     snprintf(idbuf, sizeof(idbuf), "%lu", (unsigned long) user_uid);
 786     sudo_setenv("SUDO_UID", idbuf, TRUE);
 787     snprintf(idbuf, sizeof(idbuf), "%lu", (unsigned long) user_gid);
 788     sudo_setenv("SUDO_GID", idbuf, TRUE);
 789
 790     /* Install new environment. */
 791     environ = env.envp;
 792     efree(old_envp);
 793 }
 794
 795 void
 796 insert_env_vars(env_vars)
 797     struct list_member *env_vars;
 798 {
 799     struct list_member *cur;
 800
 801     if (env_vars == NULL)
 802         return;
 803
 804     /* Add user-specified environment variables. */
 805     for (cur = env_vars; cur != NULL; cur = cur->next)
 806         putenv(cur->value);
 807 }
 808
 809 /*
 810  * Validate the list of environment variables passed in on the command
 811  * line against env_delete, env_check, and env_keep.
 812  * Calls log_error() if any specified variables are not allowed.
 813  */
 814 void
 815 validate_env_vars(env_vars)
 816     struct list_member *env_vars;
 817 {
 818     struct list_member *var;
 819     char *eq, *bad = NULL;
 820     size_t len, blen = 0, bsize = 0;
 821     int okvar;
 822
 823     for (var = env_vars; var != NULL; var = var->next) {
 824         if (def_secure_path && !user_is_exempt() &&
 825             strncmp(var->value, "PATH=", 5) == 0) {
 826             okvar = FALSE;
 827         } else if (def_env_reset) {
 828             okvar = matches_env_check(var->value);
 829             if (okvar == -1)
 830                 okvar = matches_env_keep(var->value);
 831         } else {
 832             okvar = matches_env_delete(var->value) == FALSE;
 833             if (okvar == FALSE)
 834                 okvar = matches_env_check(var->value) != FALSE;
 835         }
 836         if (okvar == FALSE) {
 837             /* Not allowed, add to error string, allocating as needed. */
 838             if ((eq = strchr(var->value, '=')) != NULL)
 839                 *eq = '\0';
 840             len = strlen(var->value) + 2;
 841             if (blen + len >= bsize) {
 842                 do {
 843                     bsize += 1024;
 844                 } while (blen + len >= bsize);
 845                 bad = erealloc(bad, bsize);
 846                 bad[blen] = '\0';
 847             }
 848             strlcat(bad, var->value, bsize);
 849             strlcat(bad, ", ", bsize);
 850             blen += len;
 851             if (eq != NULL)
 852                 *eq = '=';
 853         }
 854     }
 855     if (bad != NULL) {
 856         bad[blen - 2] = '\0';           /* remove trailing ", " */
 857         log_error(NO_MAIL,
 858             "sorry, you are not allowed to set the following environment variables: %s", bad);
 859         /* NOTREACHED */
 860         efree(bad);
 861     }
 862 }
 863
 864 /*
 865  * Read in /etc/environment ala AIX and Linux.
 866  * Lines may be in either of three formats:
 867  *  NAME=VALUE
 868  *  NAME="VALUE"
 869  *  NAME='VALUE'
 870  * with an optional "export" prefix so the shell can source the file.
 871  * Invalid lines, blank lines, or lines consisting solely of a comment
 872  * character are skipped.
 873  */
 874 void
 875 read_env_file(path, overwrite)
 876     const char *path;
 877     int overwrite;
 878 {
 879     FILE *fp;
 880     char *cp, *var, *val;
 881     size_t var_len, val_len;
 882
 883     if ((fp = fopen(path, "r")) == NULL)
 884         return;
 885
 886     while ((var = sudo_parseln(fp)) != NULL) {
 887         /* Skip blank or comment lines */
 888         if (*var == '\0')
 889             continue;
 890
 891         /* Skip optional "export " */
 892         if (strncmp(var, "export", 6) == 0 && isspace((unsigned char) var[6])) {
 893             var += 7;
 894             while (isspace((unsigned char) *var)) {
 895                 var++;
 896             }
 897         }
 898
 899         /* Must be of the form name=["']value['"] */
 900         for (val = var; *val != '\0' && *val != '='; val++)
 901             ;
 902         if (var == val || *val != '=')
 903             continue;
 904         var_len = (size_t)(val - var);
 905         val_len = strlen(++val);
 906
 907         /* Strip leading and trailing single/double quotes */
 908         if ((val[0] == '\'' || val[0] == '\"') && val[0] == val[val_len - 1]) {
 909             val[val_len - 1] = '\0';
 910             val++;
 911             val_len -= 2;
 912         }
 913
 914         cp = emalloc(var_len + 1 + val_len + 1);
 915         memcpy(cp, var, var_len + 1); /* includes '=' */
 916         memcpy(cp + var_len + 1, val, val_len + 1); /* includes NUL */
 917
 918         sudo_putenv(cp, TRUE, overwrite);
 919     }
 920     fclose(fp);
 921 }
 922
 923 void
 924 init_envtables()
 925 {
 926     struct list_member *cur;
 927     const char **p;
 928
 929     /* Fill in the "env_delete" list. */
 930     for (p = initial_badenv_table; *p; p++) {
 931         cur = emalloc(sizeof(struct list_member));
 932         cur->value = estrdup(*p);
 933         cur->next = def_env_delete;
 934         def_env_delete = cur;
 935     }
 936
 937     /* Fill in the "env_check" list. */
 938     for (p = initial_checkenv_table; *p; p++) {
 939         cur = emalloc(sizeof(struct list_member));
 940         cur->value = estrdup(*p);
 941         cur->next = def_env_check;
 942         def_env_check = cur;
 943     }
 944
 945     /* Fill in the "env_keep" list. */
 946     for (p = initial_keepenv_table; *p; p++) {
 947         cur = emalloc(sizeof(struct list_member));
 948         cur->value = estrdup(*p);
 949         cur->next = def_env_keep;
 950         def_env_keep = cur;
 951     }
 952 }