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

   1 /*
   2  * Copyright (c) 2000-2005, 2007-2011
   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 #endif /* HAVE_STRING_H */
  39 #ifdef HAVE_STRINGS_H
  40 # include <strings.h>
  41 #endif /* HAVE_STRINGS_H */
  42 #ifdef HAVE_UNISTD_H
  43 # include <unistd.h>
  44 #endif /* HAVE_UNISTD_H */
  45 #include <ctype.h>
  46 #include <errno.h>
  47 #include <pwd.h>
  48
  49 #include "sudoers.h"
  50
  51 /*
  52  * Flags used in rebuild_env()
  53  */
  54 #undef DID_TERM
  55 #define DID_TERM        0x0001
  56 #undef DID_PATH
  57 #define DID_PATH        0x0002
  58 #undef DID_HOME
  59 #define DID_HOME        0x0004
  60 #undef DID_SHELL
  61 #define DID_SHELL       0x0008
  62 #undef DID_LOGNAME
  63 #define DID_LOGNAME     0x0010
  64 #undef DID_USER
  65 #define DID_USER        0x0020
  66 #undef DID_USERNAME
  67 #define DID_USERNAME    0x0040
  68 #undef DID_MAIL
  69 #define DID_MAIL        0x0080
  70 #undef DID_MAX
  71 #define DID_MAX         0x00ff
  72
  73 #undef KEPT_TERM
  74 #define KEPT_TERM       0x0100
  75 #undef KEPT_PATH
  76 #define KEPT_PATH       0x0200
  77 #undef KEPT_HOME
  78 #define KEPT_HOME       0x0400
  79 #undef KEPT_SHELL
  80 #define KEPT_SHELL      0x0800
  81 #undef KEPT_LOGNAME
  82 #define KEPT_LOGNAME    0x1000
  83 #undef KEPT_USER
  84 #define KEPT_USER       0x2000
  85 #undef KEPT_USERNAME
  86 #define KEPT_USERNAME   0x4000
  87 #undef KEPT_MAIL
  88 #define KEPT_MAIL       0x8000
  89 #undef KEPT_MAX
  90 #define KEPT_MAX        0xff00
  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 static void sudo_setenv(const char *, const char *, int);
 102 static void sudo_putenv(char *, int, int);
 103
 104 /*
 105  * Copy of the sudo-managed environment.
 106  */
 107 static struct environment env;
 108
 109 /*
 110  * Default table of "bad" variables to remove from the environment.
 111  * XXX - how to omit TERMCAP if it starts with '/'?
 112  */
 113 static const char *initial_badenv_table[] = {
 114     "IFS",
 115     "CDPATH",
 116     "LOCALDOMAIN",
 117     "RES_OPTIONS",
 118     "HOSTALIASES",
 119     "NLSPATH",
 120     "PATH_LOCALE",
 121     "LD_*",
 122     "_RLD*",
 123 #ifdef __hpux
 124     "SHLIB_PATH",
 125 #endif /* __hpux */
 126 #ifdef _AIX
 127     "LDR_*",
 128     "LIBPATH",
 129     "AUTHSTATE",
 130 #endif
 131 #ifdef __APPLE__
 132     "DYLD_*",
 133 #endif
 134 #ifdef HAVE_KERB4
 135     "KRB_CONF*",
 136     "KRBCONFDIR",
 137     "KRBTKFILE",
 138 #endif /* HAVE_KERB4 */
 139 #ifdef HAVE_KERB5
 140     "KRB5_CONFIG*",
 141     "KRB5_KTNAME",
 142 #endif /* HAVE_KERB5 */
 143 #ifdef HAVE_SECURID
 144     "VAR_ACE",
 145     "USR_ACE",
 146     "DLC_ACE",
 147 #endif /* HAVE_SECURID */
 148     "TERMINFO",                 /* terminfo, exclusive path to terminfo files */
 149     "TERMINFO_DIRS",            /* terminfo, path(s) to terminfo files */
 150     "TERMPATH",                 /* termcap, path(s) to termcap files */
 151     "TERMCAP",                  /* XXX - only if it starts with '/' */
 152     "ENV",                      /* ksh, file to source before script runs */
 153     "BASH_ENV",                 /* bash, file to source before script runs */
 154     "PS4",                      /* bash, prefix for lines in xtrace mode */
 155     "GLOBIGNORE",               /* bash, globbing patterns to ignore */
 156     "SHELLOPTS",                /* bash, extra command line options */
 157     "JAVA_TOOL_OPTIONS",        /* java, extra command line options */
 158     "PERLIO_DEBUG ",            /* perl, debugging output file */
 159     "PERLLIB",                  /* perl, search path for modules/includes */
 160     "PERL5LIB",                 /* perl 5, search path for modules/includes */
 161     "PERL5OPT",                 /* perl 5, extra command line options */
 162     "PERL5DB",                  /* perl 5, command used to load debugger */
 163     "FPATH",                    /* ksh, search path for functions */
 164     "NULLCMD",                  /* zsh, command for null file redirection */
 165     "READNULLCMD",              /* zsh, command for null file redirection */
 166     "ZDOTDIR",                  /* zsh, search path for dot files */
 167     "TMPPREFIX",                /* zsh, prefix for temporary files */
 168     "PYTHONHOME",               /* python, module search path */
 169     "PYTHONPATH",               /* python, search path */
 170     "PYTHONINSPECT",            /* python, allow inspection */
 171     "PYTHONUSERBASE",           /* python, per user site-packages directory */
 172     "RUBYLIB",                  /* ruby, library load path */
 173     "RUBYOPT",                  /* ruby, extra command line options */
 174     NULL
 175 };
 176
 177 /*
 178  * Default table of variables to check for '%' and '/' characters.
 179  */
 180 static const char *initial_checkenv_table[] = {
 181     "COLORTERM",
 182     "LANG",
 183     "LANGUAGE",
 184     "LC_*",
 185     "LINGUAS",
 186     "TERM",
 187     NULL
 188 };
 189
 190 /*
 191  * Default table of variables to preserve in the environment.
 192  */
 193 static const char *initial_keepenv_table[] = {
 194     "COLORS",
 195     "DISPLAY",
 196     "HOSTNAME",
 197     "KRB5CCNAME",
 198     "LS_COLORS",
 199     "PATH",
 200     "PS1",
 201     "PS2",
 202     "TZ",
 203     "XAUTHORITY",
 204     "XAUTHORIZATION",
 205 #ifdef _AIX
 206     "ODMDIR",
 207 #endif
 208     NULL
 209 };
 210
 211 /*
 212  * Initialize env based on envp.
 213  */
 214 void
 215 env_init(char * const envp[])
 216 {
 217     char * const *ep;
 218     size_t len;
 219
 220     for (ep = envp; *ep != NULL; ep++)
 221         continue;
 222     len = (size_t)(ep - envp);
 223
 224     env.env_len = len;
 225     env.env_size = len + 1 + 128;
 226     env.envp = emalloc2(env.env_size, sizeof(char *));
 227 #ifdef ENV_DEBUG
 228     memset(env.envp, 0, env.env_size * sizeof(char *));
 229 #endif
 230     memcpy(env.envp, envp, len * sizeof(char *));
 231     env.envp[len] = '\0';
 232 }
 233
 234 char **
 235 env_get(void)
 236 {
 237     return env.envp;
 238 }
 239
 240 /*
 241  * Similar to setenv(3) but operates on sudo's private copy of the environment
 242  * (not environ) and it always overwrites.  The dupcheck param determines
 243  * whether we need to verify that the variable is not already set.
 244  */
 245 static void
 246 sudo_setenv(const char *var, const char *val, int dupcheck)
 247 {
 248     char *estring;
 249     size_t esize;
 250
 251     esize = strlen(var) + 1 + strlen(val) + 1;
 252     estring = emalloc(esize);
 253
 254     /* Build environment string and insert it. */
 255     if (strlcpy(estring, var, esize) >= esize ||
 256         strlcat(estring, "=", esize) >= esize ||
 257         strlcat(estring, val, esize) >= esize) {
 258
 259         errorx(1, "internal error, sudo_setenv() overflow");
 260     }
 261     sudo_putenv(estring, dupcheck, TRUE);
 262 }
 263
 264 /*
 265  * Similar to putenv(3) but operates on sudo's private copy of the
 266  * environment (not environ) and it always overwrites.  The dupcheck param
 267  * determines whether we need to verify that the variable is not already set.
 268  * Will only overwrite an existing variable if overwrite is set.
 269  */
 270 static void
 271 sudo_putenv(char *str, int dupcheck, int overwrite)
 272 {
 273     char **ep;
 274     size_t len;
 275     int found = FALSE;
 276
 277     /* Make sure there is room for the new entry plus a NULL. */
 278     if (env.env_len + 2 > env.env_size) {
 279         env.env_size += 128;
 280         env.envp = erealloc3(env.envp, env.env_size, sizeof(char *));
 281 #ifdef ENV_DEBUG
 282         memset(env.envp + env.env_len, 0,
 283             (env.env_size - env.env_len) * sizeof(char *));
 284 #endif
 285     }
 286
 287 #ifdef ENV_DEBUG
 288     if (env.envp[env.env_len] != NULL)
 289         errorx(1, "sudo_putenv: corrupted envp, len mismatch");
 290 #endif
 291
 292     if (dupcheck) {
 293         len = (strchr(str, '=') - str) + 1;
 294         for (ep = env.envp; !found && *ep != NULL; ep++) {
 295             if (strncmp(str, *ep, len) == 0) {
 296                 if (overwrite)
 297                     *ep = str;
 298                 found = TRUE;
 299             }
 300         }
 301         /* Prune out duplicate variables. */
 302         if (found && overwrite) {
 303             while (*ep != NULL) {
 304                 if (strncmp(str, *ep, len) == 0) {
 305                     char **cur = ep;
 306                     while ((*cur = *(cur + 1)) != NULL)
 307                         cur++;
 308                 } else {
 309                     ep++;
 310                 }
 311             }
 312             env.env_len = ep - env.envp;
 313         }
 314     }
 315
 316     if (!found) {
 317         ep = env.envp + env.env_len;
 318         env.env_len++;
 319         *ep++ = str;
 320         *ep = NULL;
 321     }
 322 }
 323
 324 /*
 325  * Check the env_delete blacklist.
 326  * Returns TRUE if the variable was found, else false.
 327  */
 328 static int
 329 matches_env_delete(const char *var)
 330 {
 331     struct list_member *cur;
 332     size_t len;
 333     int iswild, match = FALSE;
 334
 335     /* Skip anything listed in env_delete. */
 336     for (cur = def_env_delete; cur; cur = cur->next) {
 337         len = strlen(cur->value);
 338         /* Deal with '*' wildcard */
 339         if (cur->value[len - 1] == '*') {
 340             len--;
 341             iswild = TRUE;
 342         } else
 343             iswild = FALSE;
 344         if (strncmp(cur->value, var, len) == 0 &&
 345             (iswild || var[len] == '=')) {
 346             match = TRUE;
 347             break;
 348         }
 349     }
 350     return match;
 351 }
 352
 353 /*
 354  * Apply the env_check list.
 355  * Returns TRUE if the variable is allowed, FALSE if denied
 356  * or -1 if no match.
 357  */
 358 static int
 359 matches_env_check(const char *var)
 360 {
 361     struct list_member *cur;
 362     size_t len;
 363     int iswild, keepit = -1;
 364
 365     for (cur = def_env_check; cur; cur = cur->next) {
 366         len = strlen(cur->value);
 367         /* Deal with '*' wildcard */
 368         if (cur->value[len - 1] == '*') {
 369             len--;
 370             iswild = TRUE;
 371         } else
 372             iswild = FALSE;
 373         if (strncmp(cur->value, var, len) == 0 &&
 374             (iswild || var[len] == '=')) {
 375             keepit = !strpbrk(var, "/%");
 376             break;
 377         }
 378     }
 379     return keepit;
 380 }
 381
 382 /*
 383  * Check the env_keep list.
 384  * Returns TRUE if the variable is allowed else FALSE.
 385  */
 386 static int
 387 matches_env_keep(const char *var)
 388 {
 389     struct list_member *cur;
 390     size_t len;
 391     int iswild, keepit = FALSE;
 392
 393     for (cur = def_env_keep; cur; cur = cur->next) {
 394         len = strlen(cur->value);
 395         /* Deal with '*' wildcard */
 396         if (cur->value[len - 1] == '*') {
 397             len--;
 398             iswild = TRUE;
 399         } else
 400             iswild = FALSE;
 401         if (strncmp(cur->value, var, len) == 0 &&
 402             (iswild || var[len] == '=')) {
 403             keepit = TRUE;
 404             break;
 405         }
 406     }
 407     return keepit;
 408 }
 409
 410 /*
 411  * Build a new environment and ether clear potentially dangerous
 412  * variables from the old one or start with a clean slate.
 413  * Also adds sudo-specific variables (SUDO_*).
 414  */
 415 void
 416 rebuild_env(void)
 417 {
 418     char **old_envp, **ep, *cp, *ps1;
 419     char idbuf[MAX_UID_T_LEN];
 420     unsigned int didvar;
 421     int reset_home = FALSE;
 422
 423     /*
 424      * Either clean out the environment or reset to a safe default.
 425      */
 426     ps1 = NULL;
 427     didvar = 0;
 428     env.env_len = 0;
 429     env.env_size = 128;
 430     old_envp = env.envp;
 431     env.envp = emalloc2(env.env_size, sizeof(char *));
 432 #ifdef ENV_DEBUG
 433     memset(env.envp, 0, env.env_size * sizeof(char *));
 434 #endif
 435
 436     /* Reset HOME based on target user if configured to. */
 437     if (ISSET(sudo_mode, MODE_RUN)) {
 438         if (def_always_set_home ||
 439             ISSET(sudo_mode, MODE_RESET_HOME | MODE_LOGIN_SHELL) ||
 440             (ISSET(sudo_mode, MODE_SHELL) && def_set_home))
 441             reset_home = TRUE;
 442     }
 443
 444     if (def_env_reset || ISSET(sudo_mode, MODE_LOGIN_SHELL)) {
 445         /* Pull in vars we want to keep from the old environment. */
 446         for (ep = old_envp; *ep; ep++) {
 447             int keepit;
 448
 449             /* Skip variables with values beginning with () (bash functions) */
 450             if ((cp = strchr(*ep, '=')) != NULL) {
 451                 if (strncmp(cp, "=() ", 3) == 0)
 452                     continue;
 453             }
 454
 455             /*
 456              * First check certain variables for '%' and '/' characters.
 457              * If no match there, check the keep list.
 458              * If nothing matched, we remove it from the environment.
 459              */
 460             keepit = matches_env_check(*ep);
 461             if (keepit == -1)
 462                 keepit = matches_env_keep(*ep);
 463
 464             /* For SUDO_PS1 -> PS1 conversion. */
 465             if (strncmp(*ep, "SUDO_PS1=", 8) == 0)
 466                 ps1 = *ep + 5;
 467
 468             if (keepit) {
 469                 /* Preserve variable. */
 470                 switch (**ep) {
 471                     case 'H':
 472                         if (strncmp(*ep, "HOME=", 5) == 0)
 473                             SET(didvar, DID_HOME);
 474                         break;
 475                     case 'L':
 476                         if (strncmp(*ep, "LOGNAME=", 8) == 0)
 477                             SET(didvar, DID_LOGNAME);
 478                         break;
 479                     case 'M':
 480                         if (strncmp(*ep, "MAIL=", 5) == 0)
 481                             SET(didvar, DID_MAIL);
 482                         break;
 483                     case 'P':
 484                         if (strncmp(*ep, "PATH=", 5) == 0)
 485                             SET(didvar, DID_PATH);
 486                         break;
 487                     case 'S':
 488                         if (strncmp(*ep, "SHELL=", 6) == 0)
 489                             SET(didvar, DID_SHELL);
 490                         break;
 491                     case 'T':
 492                         if (strncmp(*ep, "TERM=", 5) == 0)
 493                             SET(didvar, DID_TERM);
 494                         break;
 495                     case 'U':
 496                         if (strncmp(*ep, "USER=", 5) == 0)
 497                             SET(didvar, DID_USER);
 498                         if (strncmp(*ep, "USERNAME=", 5) == 0)
 499                             SET(didvar, DID_USERNAME);
 500                         break;
 501                 }
 502                 sudo_putenv(*ep, FALSE, FALSE);
 503             }
 504         }
 505         didvar |= didvar << 8;          /* convert DID_* to KEPT_* */
 506
 507         /*
 508          * Add in defaults.  In -i mode these come from the runas user,
 509          * otherwise they may be from the user's environment (depends
 510          * on sudoers options).
 511          */
 512         if (ISSET(sudo_mode, MODE_LOGIN_SHELL)) {
 513             sudo_setenv("SHELL", runas_pw->pw_shell, ISSET(didvar, DID_SHELL));
 514             sudo_setenv("LOGNAME", runas_pw->pw_name,
 515                 ISSET(didvar, DID_LOGNAME));
 516             sudo_setenv("USER", runas_pw->pw_name, ISSET(didvar, DID_USER));
 517             sudo_setenv("USERNAME", runas_pw->pw_name,
 518                 ISSET(didvar, DID_USERNAME));
 519         } else {
 520             if (!ISSET(didvar, DID_SHELL))
 521                 sudo_setenv("SHELL", sudo_user.pw->pw_shell, FALSE);
 522             if (!ISSET(didvar, DID_LOGNAME))
 523                 sudo_setenv("LOGNAME", user_name, FALSE);
 524             if (!ISSET(didvar, DID_USER))
 525                 sudo_setenv("USER", user_name, FALSE);
 526             if (!ISSET(didvar, DID_USERNAME))
 527                 sudo_setenv("USERNAME", user_name, FALSE);
 528         }
 529
 530         /* If we didn't keep HOME, reset it based on target user. */
 531         if (!ISSET(didvar, KEPT_HOME))
 532             reset_home = TRUE;
 533
 534         /*
 535          * Set MAIL to target user in -i mode or if MAIL is not preserved
 536          * from user's environment.
 537          */
 538         if (ISSET(sudo_mode, MODE_LOGIN_SHELL) || !ISSET(didvar, KEPT_MAIL)) {
 539             cp = _PATH_MAILDIR;
 540             if (cp[sizeof(_PATH_MAILDIR) - 2] == '/')
 541                 easprintf(&cp, "MAIL=%s%s", _PATH_MAILDIR, runas_pw->pw_name);
 542             else
 543                 easprintf(&cp, "MAIL=%s/%s", _PATH_MAILDIR, runas_pw->pw_name);
 544             sudo_putenv(cp, ISSET(didvar, DID_MAIL), TRUE);
 545         }
 546     } else {
 547         /*
 548          * Copy environ entries as long as they don't match env_delete or
 549          * env_check.
 550          */
 551         for (ep = old_envp; *ep; ep++) {
 552             int okvar;
 553
 554             /* Skip variables with values beginning with () (bash functions) */
 555             if ((cp = strchr(*ep, '=')) != NULL) {
 556                 if (strncmp(cp, "=() ", 3) == 0)
 557                     continue;
 558             }
 559
 560             /*
 561              * First check variables against the blacklist in env_delete.
 562              * If no match there check for '%' and '/' characters.
 563              */
 564             okvar = matches_env_delete(*ep) != TRUE;
 565             if (okvar)
 566                 okvar = matches_env_check(*ep) != FALSE;
 567
 568             if (okvar) {
 569                 if (strncmp(*ep, "SUDO_PS1=", 9) == 0)
 570                     ps1 = *ep + 5;
 571                 else if (strncmp(*ep, "PATH=", 5) == 0)
 572                     SET(didvar, DID_PATH);
 573                 else if (strncmp(*ep, "TERM=", 5) == 0)
 574                     SET(didvar, DID_TERM);
 575                 sudo_putenv(*ep, FALSE, FALSE);
 576             }
 577         }
 578     }
 579     /* Replace the PATH envariable with a secure one? */
 580     if (def_secure_path && !user_is_exempt()) {
 581         sudo_setenv("PATH", def_secure_path, TRUE);
 582         SET(didvar, DID_PATH);
 583     }
 584
 585     /* Set $USER, $LOGNAME and $USERNAME to target if "set_logname" is true. */
 586     if (def_set_logname && !ISSET(sudo_mode, MODE_LOGIN_SHELL)) {
 587         if (!ISSET(didvar, KEPT_LOGNAME))
 588             sudo_setenv("LOGNAME", runas_pw->pw_name, TRUE);
 589         if (!ISSET(didvar, KEPT_USER))
 590             sudo_setenv("USER", runas_pw->pw_name, TRUE);
 591         if (!ISSET(didvar, KEPT_USERNAME))
 592             sudo_setenv("USERNAME", runas_pw->pw_name, TRUE);
 593     }
 594
 595     /* Set $HOME to target user if not preserving user's value. */
 596     if (reset_home)
 597         sudo_setenv("HOME", runas_pw->pw_dir, TRUE);
 598
 599     /* Provide default values for $TERM and $PATH if they are not set. */
 600     if (!ISSET(didvar, DID_TERM))
 601         sudo_putenv("TERM=unknown", FALSE, FALSE);
 602     if (!ISSET(didvar, DID_PATH))
 603         sudo_setenv("PATH", _PATH_STDPATH, FALSE);
 604
 605     /* Set PS1 if SUDO_PS1 is set. */
 606     if (ps1 != NULL)
 607         sudo_putenv(ps1, TRUE, TRUE);
 608
 609     /* Add the SUDO_COMMAND envariable (cmnd + args). */
 610     if (user_args) {
 611         easprintf(&cp, "%s %s", user_cmnd, user_args);
 612         sudo_setenv("SUDO_COMMAND", cp, TRUE);
 613         efree(cp);
 614     } else {
 615         sudo_setenv("SUDO_COMMAND", user_cmnd, TRUE);
 616     }
 617
 618     /* Add the SUDO_USER, SUDO_UID, SUDO_GID environment variables. */
 619     sudo_setenv("SUDO_USER", user_name, TRUE);
 620     snprintf(idbuf, sizeof(idbuf), "%u", (unsigned int) user_uid);
 621     sudo_setenv("SUDO_UID", idbuf, TRUE);
 622     snprintf(idbuf, sizeof(idbuf), "%u", (unsigned int) user_gid);
 623     sudo_setenv("SUDO_GID", idbuf, TRUE);
 624
 625     /* Free old environment. */
 626     efree(old_envp);
 627 }
 628
 629 void
 630 insert_env_vars(char * const envp[])
 631 {
 632     char * const *ep;
 633
 634     if (envp == NULL)
 635         return;
 636
 637     /* Add user-specified environment variables. */
 638     for (ep = envp; *ep != NULL; ep++)
 639         sudo_putenv(*ep, TRUE, TRUE);
 640 }
 641
 642 /*
 643  * Validate the list of environment variables passed in on the command
 644  * line against env_delete, env_check, and env_keep.
 645  * Calls log_error() if any specified variables are not allowed.
 646  */
 647 void
 648 validate_env_vars(char * const env_vars[])
 649 {
 650     char * const *ep;
 651     char *eq, *bad = NULL;
 652     size_t len, blen = 0, bsize = 0;
 653     int okvar;
 654
 655     if (env_vars == NULL)
 656         return;
 657
 658     /* Add user-specified environment variables. */
 659     for (ep = env_vars; *ep != NULL; ep++) {
 660         if (def_secure_path && !user_is_exempt() &&
 661             strncmp(*ep, "PATH=", 5) == 0) {
 662             okvar = FALSE;
 663         } else if (def_env_reset) {
 664             okvar = matches_env_check(*ep);
 665             if (okvar == -1)
 666                 okvar = matches_env_keep(*ep);
 667         } else {
 668             okvar = matches_env_delete(*ep) == FALSE;
 669             if (okvar == FALSE)
 670                 okvar = matches_env_check(*ep) != FALSE;
 671         }
 672         if (okvar == FALSE) {
 673             /* Not allowed, add to error string, allocating as needed. */
 674             if ((eq = strchr(*ep, '=')) != NULL)
 675                 *eq = '\0';
 676             len = strlen(*ep) + 2;
 677             if (blen + len >= bsize) {
 678                 do {
 679                     bsize += 1024;
 680                 } while (blen + len >= bsize);
 681                 bad = erealloc(bad, bsize);
 682                 bad[blen] = '\0';
 683             }
 684             strlcat(bad, *ep, bsize);
 685             strlcat(bad, ", ", bsize);
 686             blen += len;
 687             if (eq != NULL)
 688                 *eq = '=';
 689         }
 690     }
 691     if (bad != NULL) {
 692         bad[blen - 2] = '\0';           /* remove trailing ", " */
 693         log_error(NO_MAIL,
 694             "sorry, you are not allowed to set the following environment variables: %s", bad);
 695         /* NOTREACHED */
 696         efree(bad);
 697     }
 698 }
 699
 700 /*
 701  * Read in /etc/environment ala AIX and Linux.
 702  * Lines may be in either of three formats:
 703  *  NAME=VALUE
 704  *  NAME="VALUE"
 705  *  NAME='VALUE'
 706  * with an optional "export" prefix so the shell can source the file.
 707  * Invalid lines, blank lines, or lines consisting solely of a comment
 708  * character are skipped.
 709  */
 710 void
 711 read_env_file(const char *path, int overwrite)
 712 {
 713     FILE *fp;
 714     char *cp, *var, *val;
 715     size_t var_len, val_len;
 716
 717     if ((fp = fopen(path, "r")) == NULL)
 718         return;
 719
 720     while ((var = sudo_parseln(fp)) != NULL) {
 721         /* Skip blank or comment lines */
 722         if (*var == '\0')
 723             continue;
 724
 725         /* Skip optional "export " */
 726         if (strncmp(var, "export", 6) == 0 && isspace((unsigned char) var[6])) {
 727             var += 7;
 728             while (isspace((unsigned char) *var)) {
 729                 var++;
 730             }
 731         }
 732
 733         /* Must be of the form name=["']value['"] */
 734         for (val = var; *val != '\0' && *val != '='; val++)
 735             ;
 736         if (var == val || *val != '=')
 737             continue;
 738         var_len = (size_t)(val - var);
 739         val_len = strlen(++val);
 740
 741         /* Strip leading and trailing single/double quotes */
 742         if ((val[0] == '\'' || val[0] == '\"') && val[0] == val[val_len - 1]) {
 743             val[val_len - 1] = '\0';
 744             val++;
 745             val_len -= 2;
 746         }
 747
 748         cp = emalloc(var_len + 1 + val_len + 1);
 749         memcpy(cp, var, var_len + 1); /* includes '=' */
 750         memcpy(cp + var_len + 1, val, val_len + 1); /* includes NUL */
 751
 752         sudo_putenv(cp, TRUE, overwrite);
 753     }
 754     fclose(fp);
 755 }
 756
 757 void
 758 init_envtables(void)
 759 {
 760     struct list_member *cur;
 761     const char **p;
 762
 763     /* Fill in the "env_delete" list. */
 764     for (p = initial_badenv_table; *p; p++) {
 765         cur = emalloc(sizeof(struct list_member));
 766         cur->value = estrdup(*p);
 767         cur->next = def_env_delete;
 768         def_env_delete = cur;
 769     }
 770
 771     /* Fill in the "env_check" list. */
 772     for (p = initial_checkenv_table; *p; p++) {
 773         cur = emalloc(sizeof(struct list_member));
 774         cur->value = estrdup(*p);
 775         cur->next = def_env_check;
 776         def_env_check = cur;
 777     }
 778
 779     /* Fill in the "env_keep" list. */
 780     for (p = initial_keepenv_table; *p; p++) {
 781         cur = emalloc(sizeof(struct list_member));
 782         cur->value = estrdup(*p);
 783         cur->next = def_env_keep;
 784         def_env_keep = cur;
 785     }
 786 }