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

   1 /*
   2  * Copyright (c) 1993-1996, 1998-2011 Todd C. Miller <Todd.Miller@courtesan.com>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  *
  16  * Sponsored in part by the Defense Advanced Research Projects
  17  * Agency (DARPA) and Air Force Research Laboratory, Air Force
  18  * Materiel Command, USAF, under agreement number F39502-99-1-0512.
  19  *
  20  * For a brief history of sudo, please see the HISTORY file included
  21  * with this distribution.
  22  */
  23
  24 #define _SUDO_MAIN
  25
  26 #ifdef __TANDEM
  27 # include <floss.h>
  28 #endif
  29
  30 #include <config.h>
  31
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34 #include <sys/param.h>
  35 #include <sys/socket.h>
  36 #include <stdio.h>
  37 #ifdef STDC_HEADERS
  38 # include <stdlib.h>
  39 # include <stddef.h>
  40 #else
  41 # ifdef HAVE_STDLIB_H
  42 #  include <stdlib.h>
  43 # endif
  44 #endif /* STDC_HEADERS */
  45 #ifdef HAVE_STRING_H
  46 # if defined(HAVE_MEMORY_H) && !defined(STDC_HEADERS)
  47 #  include <memory.h>
  48 # endif
  49 # include <string.h>
  50 #endif /* HAVE_STRING_H */
  51 #ifdef HAVE_STRINGS_H
  52 # include <strings.h>
  53 #endif /* HAVE_STRINGS_H */
  54 #ifdef HAVE_UNISTD_H
  55 # include <unistd.h>
  56 #endif /* HAVE_UNISTD_H */
  57 #include <pwd.h>
  58 #include <errno.h>
  59 #include <fcntl.h>
  60 #include <signal.h>
  61 #include <grp.h>
  62 #include <time.h>
  63 #ifdef HAVE_SETLOCALE
  64 # include <locale.h>
  65 #endif
  66 #include <netinet/in.h>
  67 #include <netdb.h>
  68 #ifdef HAVE_LOGIN_CAP_H
  69 # include <login_cap.h>
  70 # ifndef LOGIN_DEFROOTCLASS
  71 #  define LOGIN_DEFROOTCLASS    "daemon"
  72 # endif
  73 # ifndef LOGIN_SETENV
  74 #  define LOGIN_SETENV  0
  75 # endif
  76 #endif
  77 #ifdef HAVE_SELINUX
  78 # include <selinux/selinux.h>
  79 #endif
  80 #include <ctype.h>
  81 #include <setjmp.h>
  82 #ifndef HAVE_GETADDRINFO
  83 # include "compat/getaddrinfo.h"
  84 #endif
  85
  86 #include "sudoers.h"
  87 #include "interfaces.h"
  88 #include "sudoers_version.h"
  89 #include "auth/sudo_auth.h"
  90 #include "secure_path.h"
  91
  92 /*
  93  * Prototypes
  94  */
  95 static void init_vars(char * const *);
  96 static int set_cmnd(void);
  97 static void set_loginclass(struct passwd *);
  98 static void set_runaspw(const char *);
  99 static void set_runasgr(const char *);
 100 static int cb_runas_default(const char *);
 101 static int sudoers_policy_version(int verbose);
 102 static int deserialize_info(char * const args[], char * const settings[],
 103     char * const user_info[]);
 104 static char *find_editor(int nfiles, char **files, char ***argv_out);
 105 static void create_admin_success_flag(void);
 106
 107 /*
 108  * Globals
 109  */
 110 struct sudo_user sudo_user;
 111 struct passwd *list_pw;
 112 struct interface *interfaces;
 113 int long_list;
 114 uid_t timestamp_uid;
 115 extern int errorlineno;
 116 extern bool parse_error;
 117 extern char *errorfile;
 118 #ifdef HAVE_BSD_AUTH_H
 119 char *login_style;
 120 #endif /* HAVE_BSD_AUTH_H */
 121 sudo_conv_t sudo_conv;
 122 sudo_printf_t sudo_printf;
 123 int sudo_mode;
 124
 125 static int sudo_version;
 126 static char *prev_user;
 127 static char *runas_user;
 128 static char *runas_group;
 129 static struct sudo_nss_list *snl;
 130 static const char *interfaces_string;
 131 static sigaction_t saved_sa_int, saved_sa_quit, saved_sa_tstp;
 132
 133 /* XXX - must be extern for audit bits of sudo_auth.c */
 134 int NewArgc;
 135 char **NewArgv;
 136
 137 /* Declared here instead of plugin_error.c for static sudo builds. */
 138 sigjmp_buf error_jmp;
 139
 140 static int
 141 sudoers_policy_open(unsigned int version, sudo_conv_t conversation,
 142     sudo_printf_t plugin_printf, char * const settings[],
 143     char * const user_info[], char * const envp[], char * const args[])
 144 {
 145     volatile int sources = 0;
 146     sigaction_t sa;
 147     struct sudo_nss *nss;
 148     struct sudo_nss *nss_next;
 149     debug_decl(sudoers_policy_open, SUDO_DEBUG_PLUGIN)
 150
 151     sudo_version = version;
 152     if (!sudo_conv)
 153         sudo_conv = conversation;
 154     if (!sudo_printf)
 155         sudo_printf = plugin_printf;
 156
 157     /* Plugin args are only specified for API version 1.2 and higher. */
 158     if (sudo_version < SUDO_API_MKVERSION(1, 2))
 159         args = NULL;
 160
 161     if (sigsetjmp(error_jmp, 1)) {
 162         /* called via error(), errorx() or log_fatal() */
 163         rewind_perms();
 164         debug_return_bool(-1);
 165     }
 166
 167     bindtextdomain("sudoers", LOCALEDIR);
 168
 169     /*
 170      * Signal setup:
 171      *  Ignore keyboard-generated signals so the user cannot interrupt
 172      *  us at some point and avoid the logging.
 173      *  Install handler to wait for children when they exit.
 174      */
 175     zero_bytes(&sa, sizeof(sa));
 176     sigemptyset(&sa.sa_mask);
 177     sa.sa_flags = SA_RESTART;
 178     sa.sa_handler = SIG_IGN;
 179     (void) sigaction(SIGINT, &sa, &saved_sa_int);
 180     (void) sigaction(SIGQUIT, &sa, &saved_sa_quit);
 181     (void) sigaction(SIGTSTP, &sa, &saved_sa_tstp);
 182
 183     sudo_setpwent();
 184     sudo_setgrent();
 185
 186     /* Initialize environment functions (including replacements). */
 187     env_init(envp);
 188
 189     /* Setup defaults data structures. */
 190     init_defaults();
 191
 192     /* Parse args, settings and user_info */
 193     sudo_mode = deserialize_info(args, settings, user_info);
 194
 195     init_vars(envp);            /* XXX - move this later? */
 196
 197     /* Parse nsswitch.conf for sudoers order. */
 198     snl = sudo_read_nss();
 199
 200     /* LDAP or NSS may modify the euid so we need to be root for the open. */
 201     set_perms(PERM_INITIAL);
 202     set_perms(PERM_ROOT);
 203
 204     /* Open and parse sudoers, set global defaults */
 205     for (nss = snl->first; nss != NULL; nss = nss_next) {
 206         nss_next = nss->next;
 207         if (nss->open(nss) == 0 && nss->parse(nss) == 0) {
 208             sources++;
 209             if (nss->setdefs(nss) != 0)
 210                 log_error(NO_STDERR, _("problem with defaults entries"));
 211         } else {
 212             tq_remove(snl, nss);
 213         }
 214     }
 215     if (sources == 0) {
 216         warningx(_("no valid sudoers sources found, quitting"));
 217         debug_return_bool(-1);
 218     }
 219
 220     /* XXX - collect post-sudoers parse settings into a function */
 221
 222     /*
 223      * Initialize external group plugin, if any.
 224      */
 225     if (def_group_plugin) {
 226         if (group_plugin_load(def_group_plugin) != true)
 227             def_group_plugin = NULL;
 228     }
 229
 230     /*
 231      * Set runas passwd/group entries based on command line or sudoers.
 232      * Note that if runas_group was specified without runas_user we
 233      * defer setting runas_pw so the match routines know to ignore it.
 234      */
 235     if (runas_group != NULL) {
 236         set_runasgr(runas_group);
 237         if (runas_user != NULL)
 238             set_runaspw(runas_user);
 239     } else
 240         set_runaspw(runas_user ? runas_user : def_runas_default);
 241
 242     if (!update_defaults(SETDEF_RUNAS))
 243         log_error(NO_STDERR, _("problem with defaults entries"));
 244
 245     if (def_fqdn)
 246         set_fqdn();     /* deferred until after sudoers is parsed */
 247
 248     /* Set login class if applicable. */
 249     set_loginclass(runas_pw ? runas_pw : sudo_user.pw);
 250
 251     restore_perms();
 252
 253     debug_return_bool(true);
 254 }
 255
 256 static void
 257 sudoers_policy_close(int exit_status, int error_code)
 258 {
 259     debug_decl(sudoers_policy_close, SUDO_DEBUG_PLUGIN)
 260
 261     if (sigsetjmp(error_jmp, 1)) {
 262         /* called via error(), errorx() or log_fatal() */
 263         debug_return;
 264     }
 265
 266     /* We do not currently log the exit status. */
 267     if (error_code)
 268         warningx(_("unable to execute %s: %s"), safe_cmnd, strerror(error_code));
 269
 270     /* Close the session we opened in sudoers_policy_init_session(). */
 271     if (ISSET(sudo_mode, MODE_RUN|MODE_EDIT))
 272         (void)sudo_auth_end_session(runas_pw);
 273
 274     /* Free remaining references to password and group entries. */
 275     sudo_pw_delref(sudo_user.pw);
 276     sudo_user.pw = NULL;
 277     sudo_pw_delref(runas_pw);
 278     runas_pw = NULL;
 279     if (runas_gr != NULL) {
 280         sudo_gr_delref(runas_gr);
 281         runas_gr = NULL;
 282     }
 283     if (user_group_list != NULL) {
 284         sudo_grlist_delref(user_group_list);
 285         user_group_list = NULL;
 286     }
 287     efree(user_gids);
 288     user_gids = NULL;
 289
 290     debug_return;
 291 }
 292
 293 /*
 294  * The init_session function is called before executing the command
 295  * and before uid/gid changes occur.
 296  * Returns 1 on success, 0 on failure and -1 on error.
 297  */
 298 static int
 299 sudoers_policy_init_session(struct passwd *pwd, char **user_env[])
 300 {
 301     debug_decl(sudoers_policy_init, SUDO_DEBUG_PLUGIN)
 302
 303     /* user_env is only specified for API version 1.2 and higher. */
 304     if (sudo_version < SUDO_API_MKVERSION(1, 2))
 305         user_env = NULL;
 306
 307     if (sigsetjmp(error_jmp, 1)) {
 308         /* called via error(), errorx() or log_fatal() */
 309         debug_return_bool(-1);
 310     }
 311
 312     debug_return_bool(sudo_auth_begin_session(pwd, user_env));
 313 }
 314
 315 static int
 316 sudoers_policy_main(int argc, char * const argv[], int pwflag, char *env_add[],
 317     char **command_infop[], char **argv_out[], char **user_env_out[])
 318 {
 319     static char *command_info[32]; /* XXX */
 320     char **edit_argv = NULL;
 321     struct sudo_nss *nss;
 322     int cmnd_status = -1, validated;
 323     volatile int info_len = 0;
 324     volatile int rval = true;
 325     debug_decl(sudoers_policy_main, SUDO_DEBUG_PLUGIN)
 326
 327     if (sigsetjmp(error_jmp, 1)) {
 328         /* error recovery via error(), errorx() or log_fatal() */
 329         rval = -1;
 330         goto done;
 331     }
 332
 333     /* Is root even allowed to run sudo? */
 334     if (user_uid == 0 && !def_root_sudo) {
 335         warningx(_("sudoers specifies that root is not allowed to sudo"));
 336         goto bad;
 337     }
 338
 339     /* Check for -C overriding def_closefrom. */
 340     if (user_closefrom >= 0 && user_closefrom != def_closefrom) {
 341         if (!def_closefrom_override) {
 342             warningx(_("you are not permitted to use the -C option"));
 343             goto bad;
 344         }
 345         def_closefrom = user_closefrom;
 346     }
 347
 348     set_perms(PERM_INITIAL);
 349
 350     /* Environment variables specified on the command line. */
 351     if (env_add != NULL && env_add[0] != NULL)
 352         sudo_user.env_vars = env_add;
 353
 354     /*
 355      * Make a local copy of argc/argv, with special handling
 356      * for pseudo-commands and the '-i' option.
 357      */
 358     if (argc == 0) {
 359         NewArgc = 1;
 360         NewArgv = emalloc2(NewArgc + 1, sizeof(char *));
 361         NewArgv[0] = user_cmnd;
 362         NewArgv[1] = NULL;
 363     } else {
 364         /* Must leave an extra slot before NewArgv for bash's --login */
 365         NewArgc = argc;
 366         NewArgv = emalloc2(NewArgc + 2, sizeof(char *));
 367         memcpy(++NewArgv, argv, argc * sizeof(char *));
 368         NewArgv[NewArgc] = NULL;
 369         if (ISSET(sudo_mode, MODE_LOGIN_SHELL) && runas_pw != NULL)
 370             NewArgv[0] = estrdup(runas_pw->pw_shell);
 371     }
 372
 373     /* If given the -P option, set the "preserve_groups" flag. */
 374     if (ISSET(sudo_mode, MODE_PRESERVE_GROUPS))
 375         def_preserve_groups = true;
 376
 377     /* Find command in path */
 378     cmnd_status = set_cmnd();
 379
 380 #ifdef HAVE_SETLOCALE
 381     if (!setlocale(LC_ALL, def_sudoers_locale)) {
 382         warningx(_("unable to set locale to \"%s\", using \"C\""),
 383             def_sudoers_locale);
 384         setlocale(LC_ALL, "C");
 385     }
 386 #endif
 387
 388     /*
 389      * Check sudoers sources.
 390      */
 391     validated = FLAG_NO_USER | FLAG_NO_HOST;
 392     tq_foreach_fwd(snl, nss) {
 393         validated = nss->lookup(nss, validated, pwflag);
 394
 395         if (ISSET(validated, VALIDATE_OK)) {
 396             /* Handle [SUCCESS=return] */
 397             if (nss->ret_if_found)
 398                 break;
 399         } else {
 400             /* Handle [NOTFOUND=return] */
 401             if (nss->ret_if_notfound)
 402                 break;
 403         }
 404     }
 405
 406     if (safe_cmnd == NULL)
 407         safe_cmnd = estrdup(user_cmnd);
 408
 409 #ifdef HAVE_SETLOCALE
 410     setlocale(LC_ALL, "");
 411 #endif
 412
 413     /* If only a group was specified, set runas_pw based on invoking user. */
 414     if (runas_pw == NULL)
 415         set_runaspw(user_name);
 416
 417     /*
 418      * Look up the timestamp dir owner if one is specified.
 419      */
 420     if (def_timestampowner) {
 421         struct passwd *pw;
 422
 423         if (*def_timestampowner == '#')
 424             pw = sudo_getpwuid(atoi(def_timestampowner + 1));
 425         else
 426             pw = sudo_getpwnam(def_timestampowner);
 427         if (pw != NULL) {
 428             timestamp_uid = pw->pw_uid;
 429             sudo_pw_delref(pw);
 430         } else {
 431             log_error(0, _("timestamp owner (%s): No such user"),
 432                 def_timestampowner);
 433             timestamp_uid = ROOT_UID;
 434         }
 435     }
 436
 437     /* If no command line args and "shell_noargs" is not set, error out. */
 438     if (ISSET(sudo_mode, MODE_IMPLIED_SHELL) && !def_shell_noargs) {
 439         rval = -2; /* usage error */
 440         goto done;
 441     }
 442
 443     /* Bail if a tty is required and we don't have one.  */
 444     if (def_requiretty) {
 445         int fd = open(_PATH_TTY, O_RDWR|O_NOCTTY);
 446         if (fd == -1) {
 447             audit_failure(NewArgv, _("no tty"));
 448             warningx(_("sorry, you must have a tty to run sudo"));
 449             goto bad;
 450         } else
 451             (void) close(fd);
 452     }
 453
 454     /*
 455      * We don't reset the environment for sudoedit or if the user
 456      * specified the -E command line flag and they have setenv privs.
 457      */
 458     if (ISSET(sudo_mode, MODE_EDIT) ||
 459         (ISSET(sudo_mode, MODE_PRESERVE_ENV) && def_setenv))
 460         def_env_reset = false;
 461
 462     /* Build a new environment that avoids any nasty bits. */
 463     rebuild_env();
 464
 465     /* Require a password if sudoers says so.  */
 466     rval = check_user(validated, sudo_mode);
 467     if (rval != true) {
 468         if (!ISSET(validated, VALIDATE_OK))
 469             log_denial(validated, false);
 470         goto done;
 471     }
 472
 473     /* If run as root with SUDO_USER set, set sudo_user.pw to that user. */
 474     /* XXX - causes confusion when root is not listed in sudoers */
 475     if (sudo_mode & (MODE_RUN | MODE_EDIT) && prev_user != NULL) {
 476         if (user_uid == 0 && strcmp(prev_user, "root") != 0) {
 477             struct passwd *pw;
 478
 479             if ((pw = sudo_getpwnam(prev_user)) != NULL) {
 480                     if (sudo_user.pw != NULL)
 481                         sudo_pw_delref(sudo_user.pw);
 482                     sudo_user.pw = pw;
 483             }
 484         }
 485     }
 486
 487     /* If the user was not allowed to run the command we are done. */
 488     if (!ISSET(validated, VALIDATE_OK)) {
 489         log_failure(validated, cmnd_status);
 490         goto bad;
 491     }
 492
 493     /* Create Ubuntu-style dot file to indicate sudo was successful. */
 494     create_admin_success_flag();
 495
 496     /* Finally tell the user if the command did not exist. */
 497     if (cmnd_status == NOT_FOUND_DOT) {
 498         audit_failure(NewArgv, _("command in current directory"));
 499         warningx(_("ignoring `%s' found in '.'\nUse `sudo ./%s' if this is the `%s' you wish to run."), user_cmnd, user_cmnd, user_cmnd);
 500         goto bad;
 501     } else if (cmnd_status == NOT_FOUND) {
 502         audit_failure(NewArgv, _("%s: command not found"), user_cmnd);
 503         warningx(_("%s: command not found"), user_cmnd);
 504         goto bad;
 505     }
 506
 507     /* If user specified env vars make sure sudoers allows it. */
 508     if (ISSET(sudo_mode, MODE_RUN) && !def_setenv) {
 509         if (ISSET(sudo_mode, MODE_PRESERVE_ENV)) {
 510             warningx(_("sorry, you are not allowed to preserve the environment"));
 511             goto bad;
 512         } else
 513             validate_env_vars(sudo_user.env_vars);
 514     }
 515
 516     if (ISSET(sudo_mode, (MODE_RUN | MODE_EDIT)) && (def_log_input || def_log_output)) {
 517         if (def_iolog_file && def_iolog_dir) {
 518             command_info[info_len++] = expand_iolog_path("iolog_path=",
 519                 def_iolog_dir, def_iolog_file, &sudo_user.iolog_file);
 520             sudo_user.iolog_file++;
 521         }
 522         if (def_log_input) {
 523             command_info[info_len++] = estrdup("iolog_stdin=true");
 524             command_info[info_len++] = estrdup("iolog_ttyin=true");
 525         }
 526         if (def_log_output) {
 527             command_info[info_len++] = estrdup("iolog_stdout=true");
 528             command_info[info_len++] = estrdup("iolog_stderr=true");
 529             command_info[info_len++] = estrdup("iolog_ttyout=true");
 530         }
 531         if (def_compress_io)
 532             command_info[info_len++] = estrdup("iolog_compress=true");
 533     }
 534
 535     log_allowed(validated);
 536     if (ISSET(sudo_mode, MODE_CHECK))
 537         rval = display_cmnd(snl, list_pw ? list_pw : sudo_user.pw);
 538     else if (ISSET(sudo_mode, MODE_LIST))
 539         display_privs(snl, list_pw ? list_pw : sudo_user.pw); /* XXX - return val */
 540
 541     /* Cleanup sudoers sources */
 542     tq_foreach_fwd(snl, nss) {
 543         nss->close(nss);
 544     }
 545     if (def_group_plugin)
 546         group_plugin_unload();
 547
 548     if (ISSET(sudo_mode, (MODE_VALIDATE|MODE_CHECK|MODE_LIST))) {
 549         /* rval already set appropriately */
 550         goto done;
 551     }
 552
 553     /*
 554      * Set umask based on sudoers.
 555      * If user's umask is more restrictive, OR in those bits too
 556      * unless umask_override is set.
 557      */
 558     if (def_umask != 0777) {
 559         mode_t mask = def_umask;
 560         if (!def_umask_override) {
 561             mode_t omask = umask(mask);
 562             mask |= omask;
 563             umask(omask);
 564         }
 565         easprintf(&command_info[info_len++], "umask=0%o", (unsigned int)mask);
 566     }
 567
 568     if (ISSET(sudo_mode, MODE_LOGIN_SHELL)) {
 569         char *p;
 570
 571         /* Convert /bin/sh -> -sh so shell knows it is a login shell */
 572         if ((p = strrchr(NewArgv[0], '/')) == NULL)
 573             p = NewArgv[0];
 574         *p = '-';
 575         NewArgv[0] = p;
 576
 577         /* Set cwd to run user's homedir. */
 578         command_info[info_len++] = fmt_string("cwd", runas_pw->pw_dir);
 579
 580         /*
 581          * Newer versions of bash require the --login option to be used
 582          * in conjunction with the -c option even if the shell name starts
 583          * with a '-'.  Unfortunately, bash 1.x uses -login, not --login
 584          * so this will cause an error for that.
 585          */
 586         if (NewArgc > 1 && strcmp(NewArgv[0], "-bash") == 0 &&
 587             strcmp(NewArgv[1], "-c") == 0) {
 588             /* Use the extra slot before NewArgv so we can store --login. */
 589             NewArgv--;
 590             NewArgc++;
 591             NewArgv[0] = NewArgv[1];
 592             NewArgv[1] = "--login";
 593         }
 594
 595 #if defined(_AIX) || (defined(__linux__) && !defined(HAVE_PAM))
 596         /* Insert system-wide environment variables. */
 597         read_env_file(_PATH_ENVIRONMENT, true);
 598 #endif
 599 #ifdef HAVE_LOGIN_CAP_H
 600         /* Set environment based on login class. */
 601         if (login_class) {
 602             login_cap_t *lc = login_getclass(login_class);
 603             if (lc != NULL) {
 604                 setusercontext(lc, runas_pw, runas_pw->pw_uid, LOGIN_SETPATH|LOGIN_SETENV);
 605                 login_close(lc);
 606             }
 607         }
 608 #endif /* HAVE_LOGIN_CAP_H */
 609     }
 610
 611     /* Insert system-wide environment variables. */
 612     if (def_env_file)
 613         read_env_file(def_env_file, false);
 614
 615     /* Insert user-specified environment variables. */
 616     insert_env_vars(sudo_user.env_vars);
 617
 618     /* Restore signal handlers before we exec. */
 619     (void) sigaction(SIGINT, &saved_sa_int, NULL);
 620     (void) sigaction(SIGQUIT, &saved_sa_quit, NULL);
 621     (void) sigaction(SIGTSTP, &saved_sa_tstp, NULL);
 622
 623     if (ISSET(sudo_mode, MODE_EDIT)) {
 624         char *editor = find_editor(NewArgc - 1, NewArgv + 1, &edit_argv);
 625         if (editor == NULL)
 626             goto bad;
 627         command_info[info_len++] = fmt_string("command", editor);
 628         command_info[info_len++] = estrdup("sudoedit=true");
 629     } else {
 630         command_info[info_len++] = fmt_string("command", safe_cmnd);
 631     }
 632     if (def_stay_setuid) {
 633         easprintf(&command_info[info_len++], "runas_uid=%u",
 634             (unsigned int)user_uid);
 635         easprintf(&command_info[info_len++], "runas_gid=%u",
 636             (unsigned int)user_gid);
 637         easprintf(&command_info[info_len++], "runas_euid=%u",
 638             (unsigned int)runas_pw->pw_uid);
 639         easprintf(&command_info[info_len++], "runas_egid=%u",
 640             runas_gr ? (unsigned int)runas_gr->gr_gid :
 641             (unsigned int)runas_pw->pw_gid);
 642     } else {
 643         easprintf(&command_info[info_len++], "runas_uid=%u",
 644             (unsigned int)runas_pw->pw_uid);
 645         easprintf(&command_info[info_len++], "runas_gid=%u",
 646             runas_gr ? (unsigned int)runas_gr->gr_gid :
 647             (unsigned int)runas_pw->pw_gid);
 648     }
 649     if (def_preserve_groups) {
 650         command_info[info_len++] = "preserve_groups=true";
 651     } else {
 652         int i, len;
 653         gid_t egid;
 654         size_t glsize;
 655         char *cp, *gid_list;
 656         struct group_list *grlist = sudo_get_grlist(runas_pw);
 657
 658         /* We reserve an extra spot in the list for the effective gid. */
 659         glsize = sizeof("runas_groups=") - 1 +
 660             ((grlist->ngids + 1) * (MAX_UID_T_LEN + 1));
 661         gid_list = emalloc(glsize);
 662         memcpy(gid_list, "runas_groups=", sizeof("runas_groups=") - 1);
 663         cp = gid_list + sizeof("runas_groups=") - 1;
 664
 665         /* On BSD systems the effective gid is the first group in the list. */
 666         egid = runas_gr ? (unsigned int)runas_gr->gr_gid :
 667             (unsigned int)runas_pw->pw_gid;
 668         len = snprintf(cp, glsize - (cp - gid_list), "%u", egid);
 669         if (len < 0 || len >= glsize - (cp - gid_list))
 670             errorx(1, _("internal error, %s overflow"), "runas_groups");
 671         cp += len;
 672         for (i = 0; i < grlist->ngids; i++) {
 673             if (grlist->gids[i] != egid) {
 674                 len = snprintf(cp, glsize - (cp - gid_list), ",%u",
 675                      (unsigned int) grlist->gids[i]);
 676                 if (len < 0 || len >= glsize - (cp - gid_list))
 677                     errorx(1, _("internal error, %s overflow"), "runas_groups");
 678                 cp += len;
 679             }
 680         }
 681         command_info[info_len++] = gid_list;
 682         sudo_grlist_delref(grlist);
 683     }
 684     if (def_closefrom >= 0)
 685         easprintf(&command_info[info_len++], "closefrom=%d", def_closefrom);
 686     if (def_noexec)
 687         command_info[info_len++] = estrdup("noexec=true");
 688     if (def_set_utmp)
 689         command_info[info_len++] = estrdup("set_utmp=true");
 690     if (def_use_pty)
 691         command_info[info_len++] = estrdup("use_pty=true");
 692     if (def_utmp_runas)
 693         command_info[info_len++] = fmt_string("utmp_user", runas_pw->pw_name);
 694 #ifdef HAVE_LOGIN_CAP_H
 695     if (def_use_loginclass)
 696         command_info[info_len++] = fmt_string("login_class", login_class);
 697 #endif /* HAVE_LOGIN_CAP_H */
 698 #ifdef HAVE_SELINUX
 699     if (user_role != NULL)
 700         command_info[info_len++] = fmt_string("selinux_role", user_role);
 701     if (user_type != NULL)
 702         command_info[info_len++] = fmt_string("selinux_type", user_type);
 703 #endif /* HAVE_SELINUX */
 704 #ifdef HAVE_PRIV_SET
 705     if (runas_privs != NULL)
 706         command_info[info_len++] = fmt_string("runas_privs", runas_privs);
 707     if (runas_limitprivs != NULL)
 708         command_info[info_len++] = fmt_string("runas_limitprivs", runas_limitprivs);
 709 #endif /* HAVE_SELINUX */
 710
 711     /* Must audit before uid change. */
 712     audit_success(NewArgv);
 713
 714     *command_infop = command_info;
 715
 716     *argv_out = edit_argv ? edit_argv : NewArgv;
 717
 718     /* Get private version of the environment and zero out stashed copy. */
 719     *user_env_out = env_get();
 720     env_init(NULL);
 721
 722     goto done;
 723
 724 bad:
 725     rval = false;
 726
 727 done:
 728     rewind_perms();
 729
 730     /* Close the password and group files and free up memory. */
 731     sudo_endpwent();
 732     sudo_endgrent();
 733
 734     debug_return_bool(rval);
 735 }
 736
 737 static int
 738 sudoers_policy_check(int argc, char * const argv[], char *env_add[],
 739     char **command_infop[], char **argv_out[], char **user_env_out[])
 740 {
 741     debug_decl(sudoers_policy_check, SUDO_DEBUG_PLUGIN)
 742
 743     if (!ISSET(sudo_mode, MODE_EDIT))
 744         SET(sudo_mode, MODE_RUN);
 745
 746     debug_return_bool(sudoers_policy_main(argc, argv, 0, env_add, command_infop,
 747         argv_out, user_env_out));
 748 }
 749
 750 static int
 751 sudoers_policy_validate(void)
 752 {
 753     debug_decl(sudoers_policy_validate, SUDO_DEBUG_PLUGIN)
 754
 755     user_cmnd = "validate";
 756     SET(sudo_mode, MODE_VALIDATE);
 757
 758     debug_return_bool(sudoers_policy_main(0, NULL, I_VERIFYPW, NULL, NULL, NULL, NULL));
 759 }
 760
 761 static void
 762 sudoers_policy_invalidate(int remove)
 763 {
 764     debug_decl(sudoers_policy_invalidate, SUDO_DEBUG_PLUGIN)
 765
 766     user_cmnd = "kill";
 767     if (sigsetjmp(error_jmp, 1) == 0) {
 768         remove_timestamp(remove);
 769         plugin_cleanup(0);
 770     }
 771
 772     debug_return;
 773 }
 774
 775 static int
 776 sudoers_policy_list(int argc, char * const argv[], int verbose,
 777     const char *list_user)
 778 {
 779     int rval;
 780     debug_decl(sudoers_policy_list, SUDO_DEBUG_PLUGIN)
 781
 782     user_cmnd = "list";
 783     if (argc)
 784         SET(sudo_mode, MODE_CHECK);
 785     else
 786         SET(sudo_mode, MODE_LIST);
 787     if (verbose)
 788         long_list = 1;
 789     if (list_user) {
 790         list_pw = sudo_getpwnam(list_user);
 791         if (list_pw == NULL) {
 792             warningx(_("unknown user: %s"), list_user);
 793             debug_return_bool(-1);
 794         }
 795     }
 796     rval = sudoers_policy_main(argc, argv, I_LISTPW, NULL, NULL, NULL, NULL);
 797     if (list_user) {
 798         sudo_pw_delref(list_pw);
 799         list_pw = NULL;
 800     }
 801
 802     debug_return_bool(rval);
 803 }
 804
 805 /*
 806  * Initialize timezone, set umask, fill in ``sudo_user'' struct and
 807  * load the ``interfaces'' array.
 808  */
 809 static void
 810 init_vars(char * const envp[])
 811 {
 812     char * const * ep;
 813     debug_decl(init_vars, SUDO_DEBUG_PLUGIN)
 814
 815 #ifdef HAVE_TZSET
 816     (void) tzset();             /* set the timezone if applicable */
 817 #endif /* HAVE_TZSET */
 818
 819     for (ep = envp; *ep; ep++) {
 820         /* XXX - don't fill in if empty string */
 821         switch (**ep) {
 822             case 'K':
 823                 if (strncmp("KRB5CCNAME=", *ep, 11) == 0)
 824                     user_ccname = *ep + 11;
 825                 break;
 826             case 'P':
 827                 if (strncmp("PATH=", *ep, 5) == 0)
 828                     user_path = *ep + 5;
 829                 break;
 830             case 'S':
 831                 if (!user_prompt && strncmp("SUDO_PROMPT=", *ep, 12) == 0)
 832                     user_prompt = *ep + 12;
 833                 else if (strncmp("SUDO_USER=", *ep, 10) == 0)
 834                     prev_user = *ep + 10;
 835                 break;
 836             }
 837     }
 838
 839     /*
 840      * Get a local copy of the user's struct passwd with the shadow password
 841      * if necessary.  It is assumed that euid is 0 at this point so we
 842      * can read the shadow passwd file if necessary.
 843      */
 844     if ((sudo_user.pw = sudo_getpwuid(user_uid)) == NULL) {
 845         /*
 846          * It is not unusual for users to place "sudo -k" in a .logout
 847          * file which can cause sudo to be run during reboot after the
 848          * YP/NIS/NIS+/LDAP/etc daemon has died.
 849          */
 850         if (sudo_mode == MODE_KILL || sudo_mode == MODE_INVALIDATE)
 851             errorx(1, _("unknown uid: %u"), (unsigned int) user_uid);
 852
 853         /* Need to make a fake struct passwd for the call to log_fatal(). */
 854         sudo_user.pw = sudo_fakepwnamid(user_name, user_uid, user_gid);
 855         log_fatal(0, _("unknown uid: %u"), (unsigned int) user_uid);
 856         /* NOTREACHED */
 857     }
 858
 859     /*
 860      * Get group list.
 861      */
 862     if (user_group_list == NULL)
 863         user_group_list = sudo_get_grlist(sudo_user.pw);
 864
 865     /* Set runas callback. */
 866     sudo_defs_table[I_RUNAS_DEFAULT].callback = cb_runas_default;
 867
 868     /* It is now safe to use log_fatal() and set_perms() */
 869     debug_return;
 870 }
 871
 872 /*
 873  * Fill in user_cmnd, user_args, user_base and user_stat variables
 874  * and apply any command-specific defaults entries.
 875  */
 876 static int
 877 set_cmnd(void)
 878 {
 879     int rval;
 880     char *path = user_path;
 881     debug_decl(set_cmnd, SUDO_DEBUG_PLUGIN)
 882
 883     /* Resolve the path and return. */
 884     rval = FOUND;
 885     user_stat = ecalloc(1, sizeof(struct stat));
 886
 887     /* Default value for cmnd, overridden below. */
 888     if (user_cmnd == NULL)
 889         user_cmnd = NewArgv[0];
 890
 891     if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {
 892         if (ISSET(sudo_mode, MODE_RUN | MODE_CHECK)) {
 893             if (def_secure_path && !user_is_exempt())
 894                 path = def_secure_path;
 895             set_perms(PERM_RUNAS);
 896             rval = find_path(NewArgv[0], &user_cmnd, user_stat, path,
 897                 def_ignore_dot);
 898             restore_perms();
 899             if (rval != FOUND) {
 900                 /* Failed as root, try as invoking user. */
 901                 set_perms(PERM_USER);
 902                 rval = find_path(NewArgv[0], &user_cmnd, user_stat, path,
 903                     def_ignore_dot);
 904                 restore_perms();
 905             }
 906         }
 907
 908         /* set user_args */
 909         if (NewArgc > 1) {
 910             char *to, *from, **av;
 911             size_t size, n;
 912
 913             /* Alloc and build up user_args. */
 914             for (size = 0, av = NewArgv + 1; *av; av++)
 915                 size += strlen(*av) + 1;
 916             user_args = emalloc(size);
 917             if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {
 918                 /*
 919                  * When running a command via a shell, the sudo front-end
 920                  * escapes potential meta chars.  We unescape non-spaces
 921                  * for sudoers matching and logging purposes.
 922                  */
 923                 for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
 924                     while (*from) {
 925                         if (from[0] == '\\' && !isspace((unsigned char)from[1]))
 926                             from++;
 927                         *to++ = *from++;
 928                     }
 929                     *to++ = ' ';
 930                 }
 931                 *--to = '\0';
 932             } else {
 933                 for (to = user_args, av = NewArgv + 1; *av; av++) {
 934                     n = strlcpy(to, *av, size - (to - user_args));
 935                     if (n >= size - (to - user_args))
 936                         errorx(1, _("internal error, %s overflow"), "set_cmnd()");
 937                     to += n;
 938                     *to++ = ' ';
 939                 }
 940                 *--to = '\0';
 941             }
 942         }
 943     }
 944     if (strlen(user_cmnd) >= PATH_MAX)
 945         errorx(1, _("%s: %s"), user_cmnd, strerror(ENAMETOOLONG));
 946
 947     if ((user_base = strrchr(user_cmnd, '/')) != NULL)
 948         user_base++;
 949     else
 950         user_base = user_cmnd;
 951
 952     if (!update_defaults(SETDEF_CMND))
 953         log_error(NO_STDERR, _("problem with defaults entries"));
 954
 955     debug_return_int(rval);
 956 }
 957
 958 /*
 959  * Open sudoers and sanity check mode/owner/type.
 960  * Returns a handle to the sudoers file or NULL on error.
 961  */
 962 FILE *
 963 open_sudoers(const char *sudoers, bool doedit, bool *keepopen)
 964 {
 965     struct stat sb;
 966     FILE *fp = NULL;
 967     debug_decl(open_sudoers, SUDO_DEBUG_PLUGIN)
 968
 969     set_perms(PERM_SUDOERS);
 970
 971     switch (sudo_secure_file(sudoers, sudoers_uid, sudoers_gid, &sb)) {
 972         case SUDO_PATH_SECURE:
 973             /*
 974              * If we are expecting sudoers to be group readable but
 975              * it is not, we must open the file as root, not uid 1.
 976              */
 977             if (sudoers_uid == ROOT_UID && (sudoers_mode & S_IRGRP)) {
 978                 if ((sb.st_mode & S_IRGRP) == 0) {
 979                     restore_perms();
 980                     set_perms(PERM_ROOT);
 981                 }
 982             }
 983             /*
 984              * Open sudoers and make sure we can read it so we can present
 985              * the user with a reasonable error message (unlike the lexer).
 986              */
 987             if ((fp = fopen(sudoers, "r")) == NULL) {
 988                 log_error(USE_ERRNO, _("unable to open %s"), sudoers);
 989             } else {
 990                 if (sb.st_size != 0 && fgetc(fp) == EOF) {
 991                     log_error(USE_ERRNO, _("unable to read %s"),
 992                         sudoers);
 993                     fclose(fp);
 994                     fp = NULL;
 995                 } else {
 996                     /* Rewind fp and set close on exec flag. */
 997                     rewind(fp);
 998                     (void) fcntl(fileno(fp), F_SETFD, 1);
 999                 }
1000             }
1001             break;
1002         case SUDO_PATH_MISSING:
1003             log_error(USE_ERRNO, _("unable to stat %s"), sudoers);
1004             break;
1005         case SUDO_PATH_BAD_TYPE:
1006             log_error(0, _("%s is not a regular file"), sudoers);
1007             break;
1008         case SUDO_PATH_WRONG_OWNER:
1009             log_error(0, _("%s is owned by uid %u, should be %u"),
1010                 sudoers, (unsigned int) sb.st_uid, (unsigned int) sudoers_uid);
1011             break;
1012         case SUDO_PATH_WORLD_WRITABLE:
1013             log_error(0, _("%s is world writable"), sudoers);
1014             break;
1015         case SUDO_PATH_GROUP_WRITABLE:
1016             log_error(0, _("%s is owned by gid %u, should be %u"),
1017                 sudoers, (unsigned int) sb.st_gid, (unsigned int) sudoers_gid);
1018             break;
1019         default:
1020             /* NOTREACHED */
1021             break;
1022     }
1023
1024     restore_perms();            /* change back to root */
1025
1026     debug_return_ptr(fp);
1027 }
1028
1029 #ifdef HAVE_LOGIN_CAP_H
1030 static void
1031 set_loginclass(struct passwd *pw)
1032 {
1033     const int errflags = NO_MAIL|MSG_ONLY;
1034     login_cap_t *lc;
1035     debug_decl(set_loginclass, SUDO_DEBUG_PLUGIN)
1036
1037     if (!def_use_loginclass)
1038         debug_return;
1039
1040     if (login_class && strcmp(login_class, "-") != 0) {
1041         if (user_uid != 0 &&
1042             strcmp(runas_user ? runas_user : def_runas_default, "root") != 0)
1043             errorx(1, _("only root can use `-c %s'"), login_class);
1044     } else {
1045         login_class = pw->pw_class;
1046         if (!login_class || !*login_class)
1047             login_class =
1048                 (pw->pw_uid == 0) ? LOGIN_DEFROOTCLASS : LOGIN_DEFCLASS;
1049     }
1050
1051     /* Make sure specified login class is valid. */
1052     lc = login_getclass(login_class);
1053     if (!lc || !lc->lc_class || strcmp(lc->lc_class, login_class) != 0) {
1054         /*
1055          * Don't make it a fatal error if the user didn't specify the login
1056          * class themselves.  We do this because if login.conf gets
1057          * corrupted we want the admin to be able to use sudo to fix it.
1058          */
1059         if (login_class)
1060             log_fatal(errflags, _("unknown login class: %s"), login_class);
1061         else
1062             log_error(errflags, _("unknown login class: %s"), login_class);
1063         def_use_loginclass = false;
1064     }
1065     login_close(lc);
1066     debug_return;
1067 }
1068 #else
1069 static void
1070 set_loginclass(struct passwd *pw)
1071 {
1072 }
1073 #endif /* HAVE_LOGIN_CAP_H */
1074
1075 #ifndef AI_FQDN
1076 # define AI_FQDN AI_CANONNAME
1077 #endif
1078
1079 /*
1080  * Look up the fully qualified domain name and set user_host and user_shost.
1081  * Use AI_FQDN if available since "canonical" is not always the same as fqdn.
1082  */
1083 void
1084 set_fqdn(void)
1085 {
1086     struct addrinfo *res0, hint;
1087     char *p;
1088     debug_decl(set_fqdn, SUDO_DEBUG_PLUGIN)
1089
1090     zero_bytes(&hint, sizeof(hint));
1091     hint.ai_family = PF_UNSPEC;
1092     hint.ai_flags = AI_FQDN;
1093     if (getaddrinfo(user_host, NULL, &hint, &res0) != 0) {
1094         log_error(MSG_ONLY, _("unable to resolve host %s"), user_host);
1095     } else {
1096         if (user_shost != user_host)
1097             efree(user_shost);
1098         efree(user_host);
1099         user_host = estrdup(res0->ai_canonname);
1100         freeaddrinfo(res0);
1101         if ((p = strchr(user_host, '.')) != NULL)
1102             user_shost = estrndup(user_host, (size_t)(p - user_host));
1103         else
1104             user_shost = user_host;
1105     }
1106     debug_return;
1107 }
1108
1109 /*
1110  * Get passwd entry for the user we are going to run commands as
1111  * and store it in runas_pw.  By default, commands run as "root".
1112  */
1113 static void
1114 set_runaspw(const char *user)
1115 {
1116     debug_decl(set_runaspw, SUDO_DEBUG_PLUGIN)
1117
1118     if (runas_pw != NULL)
1119         sudo_pw_delref(runas_pw);
1120     if (*user == '#') {
1121         if ((runas_pw = sudo_getpwuid(atoi(user + 1))) == NULL)
1122             runas_pw = sudo_fakepwnam(user, runas_gr ? runas_gr->gr_gid : 0);
1123     } else {
1124         if ((runas_pw = sudo_getpwnam(user)) == NULL)
1125             log_fatal(NO_MAIL|MSG_ONLY, _("unknown user: %s"), user);
1126     }
1127     debug_return;
1128 }
1129
1130 /*
1131  * Get group entry for the group we are going to run commands as
1132  * and store it in runas_gr.
1133  */
1134 static void
1135 set_runasgr(const char *group)
1136 {
1137     debug_decl(set_runasgr, SUDO_DEBUG_PLUGIN)
1138
1139     if (runas_gr != NULL)
1140         sudo_gr_delref(runas_gr);
1141     if (*group == '#') {
1142         if ((runas_gr = sudo_getgrgid(atoi(group + 1))) == NULL)
1143             runas_gr = sudo_fakegrnam(group);
1144     } else {
1145         if ((runas_gr = sudo_getgrnam(group)) == NULL)
1146             log_fatal(NO_MAIL|MSG_ONLY, _("unknown group: %s"), group);
1147     }
1148     debug_return;
1149 }
1150
1151 /*
1152  * Callback for runas_default sudoers setting.
1153  */
1154 static int
1155 cb_runas_default(const char *user)
1156 {
1157     /* Only reset runaspw if user didn't specify one. */
1158     if (!runas_user && !runas_group)
1159         set_runaspw(user);
1160     return true;
1161 }
1162
1163 /*
1164  * Cleanup hook for error()/errorx()
1165  */
1166 void
1167 plugin_cleanup(int gotsignal)
1168 {
1169     struct sudo_nss *nss;
1170
1171     if (!gotsignal) {
1172         debug_decl(plugin_cleanup, SUDO_DEBUG_PLUGIN)
1173         if (snl != NULL) {
1174             tq_foreach_fwd(snl, nss)
1175                 nss->close(nss);
1176         }
1177         if (def_group_plugin)
1178             group_plugin_unload();
1179         sudo_endpwent();
1180         sudo_endgrent();
1181         debug_return;
1182     }
1183 }
1184
1185 static int
1186 sudoers_policy_version(int verbose)
1187 {
1188     debug_decl(sudoers_policy_version, SUDO_DEBUG_PLUGIN)
1189
1190     if (sigsetjmp(error_jmp, 1)) {
1191         /* error recovery via error(), errorx() or log_fatal() */
1192         debug_return_bool(-1);
1193     }
1194
1195     sudo_printf(SUDO_CONV_INFO_MSG, _("Sudoers policy plugin version %s\n"),
1196         PACKAGE_VERSION);
1197     sudo_printf(SUDO_CONV_INFO_MSG, _("Sudoers file grammar version %d\n"),
1198         SUDOERS_GRAMMAR_VERSION);
1199
1200     if (verbose) {
1201         sudo_printf(SUDO_CONV_INFO_MSG, _("\nSudoers path: %s\n"), sudoers_file);
1202 #ifdef HAVE_LDAP
1203 # ifdef _PATH_NSSWITCH_CONF
1204         sudo_printf(SUDO_CONV_INFO_MSG, _("nsswitch path: %s\n"), _PATH_NSSWITCH_CONF);
1205 # endif
1206         sudo_printf(SUDO_CONV_INFO_MSG, _("ldap.conf path: %s\n"), _PATH_LDAP_CONF);
1207         sudo_printf(SUDO_CONV_INFO_MSG, _("ldap.secret path: %s\n"), _PATH_LDAP_SECRET);
1208 #endif
1209         dump_auth_methods();
1210         dump_defaults();
1211         sudo_printf(SUDO_CONV_INFO_MSG, "\n");
1212         if (interfaces_string != NULL) {
1213             dump_interfaces(interfaces_string);
1214             sudo_printf(SUDO_CONV_INFO_MSG, "\n");
1215         }
1216     }
1217     debug_return_bool(true);
1218 }
1219
1220 static int
1221 deserialize_info(char * const args[], char * const settings[], char * const user_info[])
1222 {
1223     char * const *cur;
1224     const char *p, *groups = NULL;
1225     const char *debug_flags = NULL;
1226     int flags = 0;
1227     debug_decl(deserialize_info, SUDO_DEBUG_PLUGIN)
1228
1229 #define MATCHES(s, v) (strncmp(s, v, sizeof(v) - 1) == 0)
1230
1231     /* Parse sudo.conf plugin args. */
1232     if (args != NULL) {
1233         for (cur = args; *cur != NULL; cur++) {
1234             if (MATCHES(*cur, "sudoers_file=")) {
1235                 sudoers_file = *cur + sizeof("sudoers_file=") - 1;
1236                 continue;
1237             }
1238             if (MATCHES(*cur, "sudoers_uid=")) {
1239                 sudoers_uid = (uid_t) atoi(*cur + sizeof("sudoers_uid=") - 1);
1240                 continue;
1241             }
1242             if (MATCHES(*cur, "sudoers_gid=")) {
1243                 sudoers_gid = (gid_t) atoi(*cur + sizeof("sudoers_gid=") - 1);
1244                 continue;
1245             }
1246             if (MATCHES(*cur, "sudoers_mode=")) {
1247                 sudoers_mode = (mode_t) strtol(*cur + sizeof("sudoers_mode=") - 1,
1248                     NULL, 8);
1249                 continue;
1250             }
1251         }
1252     }
1253
1254     /* Parse command line settings. */
1255     user_closefrom = -1;
1256     for (cur = settings; *cur != NULL; cur++) {
1257         if (MATCHES(*cur, "closefrom=")) {
1258             user_closefrom = atoi(*cur + sizeof("closefrom=") - 1);
1259             continue;
1260         }
1261         if (MATCHES(*cur, "debug_flags=")) {
1262             debug_flags = *cur + sizeof("debug_flags=") - 1;
1263             continue;
1264         }
1265         if (MATCHES(*cur, "runas_user=")) {
1266             runas_user = *cur + sizeof("runas_user=") - 1;
1267             sudo_user.flags |= RUNAS_USER_SPECIFIED;
1268             continue;
1269         }
1270         if (MATCHES(*cur, "runas_group=")) {
1271             runas_group = *cur + sizeof("runas_group=") - 1;
1272             sudo_user.flags |= RUNAS_GROUP_SPECIFIED;
1273             continue;
1274         }
1275         if (MATCHES(*cur, "prompt=")) {
1276             user_prompt = *cur + sizeof("prompt=") - 1;
1277             def_passprompt_override = true;
1278             continue;
1279         }
1280         if (MATCHES(*cur, "set_home=")) {
1281             if (atobool(*cur + sizeof("set_home=") - 1) == true)
1282                 SET(flags, MODE_RESET_HOME);
1283             continue;
1284         }
1285         if (MATCHES(*cur, "preserve_environment=")) {
1286             if (atobool(*cur + sizeof("preserve_environment=") - 1) == true)
1287                 SET(flags, MODE_PRESERVE_ENV);
1288             continue;
1289         }
1290         if (MATCHES(*cur, "run_shell=")) {
1291             if (atobool(*cur + sizeof("run_shell=") - 1) == true)
1292                 SET(flags, MODE_SHELL);
1293             continue;
1294         }
1295         if (MATCHES(*cur, "login_shell=")) {
1296             if (atobool(*cur + sizeof("login_shell=") - 1) == true) {
1297                 SET(flags, MODE_LOGIN_SHELL);
1298                 def_env_reset = true;
1299             }
1300             continue;
1301         }
1302         if (MATCHES(*cur, "implied_shell=")) {
1303             if (atobool(*cur + sizeof("implied_shell=") - 1) == true)
1304                 SET(flags, MODE_IMPLIED_SHELL);
1305             continue;
1306         }
1307         if (MATCHES(*cur, "preserve_groups=")) {
1308             if (atobool(*cur + sizeof("preserve_groups=") - 1) == true)
1309                 SET(flags, MODE_PRESERVE_GROUPS);
1310             continue;
1311         }
1312         if (MATCHES(*cur, "ignore_ticket=")) {
1313             if (atobool(*cur + sizeof("ignore_ticket=") - 1) == true)
1314                 SET(flags, MODE_IGNORE_TICKET);
1315             continue;
1316         }
1317         if (MATCHES(*cur, "noninteractive=")) {
1318             if (atobool(*cur + sizeof("noninteractive=") - 1) == true)
1319                 SET(flags, MODE_NONINTERACTIVE);
1320             continue;
1321         }
1322         if (MATCHES(*cur, "sudoedit=")) {
1323             if (atobool(*cur + sizeof("sudoedit=") - 1) == true)
1324                 SET(flags, MODE_EDIT);
1325             continue;
1326         }
1327         if (MATCHES(*cur, "login_class=")) {
1328             login_class = *cur + sizeof("login_class=") - 1;
1329             def_use_loginclass = true;
1330             continue;
1331         }
1332 #ifdef HAVE_PRIV_SET
1333         if (MATCHES(*cur, "runas_privs=")) {
1334             def_privs = *cur + sizeof("runas_privs=") - 1;
1335             continue;
1336         }
1337         if (MATCHES(*cur, "runas_limitprivs=")) {
1338             def_limitprivs = *cur + sizeof("runas_limitprivs=") - 1;
1339             continue;
1340         }
1341 #endif /* HAVE_PRIV_SET */
1342 #ifdef HAVE_SELINUX
1343         if (MATCHES(*cur, "selinux_role=")) {
1344             user_role = *cur + sizeof("selinux_role=") - 1;
1345             continue;
1346         }
1347         if (MATCHES(*cur, "selinux_type=")) {
1348             user_type = *cur + sizeof("selinux_type=") - 1;
1349             continue;
1350         }
1351 #endif /* HAVE_SELINUX */
1352 #ifdef HAVE_BSD_AUTH_H
1353         if (MATCHES(*cur, "bsdauth_type=")) {
1354             login_style = *cur + sizeof("bsdauth_type=") - 1;
1355             continue;
1356         }
1357 #endif /* HAVE_BSD_AUTH_H */
1358 #if !defined(HAVE_GETPROGNAME) && !defined(HAVE___PROGNAME)
1359         if (MATCHES(*cur, "progname=")) {
1360             setprogname(*cur + sizeof("progname=") - 1);
1361             continue;
1362         }
1363 #endif
1364         if (MATCHES(*cur, "network_addrs=")) {
1365             interfaces_string = *cur + sizeof("network_addrs=") - 1;
1366             set_interfaces(interfaces_string);
1367             continue;
1368         }
1369     }
1370
1371     for (cur = user_info; *cur != NULL; cur++) {
1372         if (MATCHES(*cur, "user=")) {
1373             user_name = estrdup(*cur + sizeof("user=") - 1);
1374             continue;
1375         }
1376         if (MATCHES(*cur, "uid=")) {
1377             user_uid = (uid_t) atoi(*cur + sizeof("uid=") - 1);
1378             continue;
1379         }
1380         if (MATCHES(*cur, "gid=")) {
1381             p = *cur + sizeof("gid=") - 1;
1382             user_gid = (gid_t) atoi(p);
1383             continue;
1384         }
1385         if (MATCHES(*cur, "groups=")) {
1386             groups = *cur + sizeof("groups=") - 1;
1387             continue;
1388         }
1389         if (MATCHES(*cur, "cwd=")) {
1390             user_cwd = estrdup(*cur + sizeof("cwd=") - 1);
1391             continue;
1392         }
1393         if (MATCHES(*cur, "tty=")) {
1394             user_tty = user_ttypath = estrdup(*cur + sizeof("tty=") - 1);
1395             if (strncmp(user_tty, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
1396                 user_tty += sizeof(_PATH_DEV) - 1;
1397             continue;
1398         }
1399         if (MATCHES(*cur, "host=")) {
1400             user_host = user_shost = estrdup(*cur + sizeof("host=") - 1);
1401             if ((p = strchr(user_host, '.')))
1402                 user_shost = estrndup(user_host, (size_t)(p - user_host));
1403             continue;
1404         }
1405         if (MATCHES(*cur, "lines=")) {
1406             sudo_user.lines = atoi(*cur + sizeof("lines=") - 1);
1407             continue;
1408         }
1409         if (MATCHES(*cur, "cols=")) {
1410             sudo_user.cols = atoi(*cur + sizeof("cols=") - 1);
1411             continue;
1412         }
1413         if (MATCHES(*cur, "sid=")) {
1414             sudo_user.sid = atoi(*cur + sizeof("sid=") - 1);
1415             continue;
1416         }
1417     }
1418     if (user_cwd == NULL)
1419         user_cwd = "unknown";
1420     if (user_tty == NULL)
1421         user_tty = "unknown"; /* user_ttypath remains NULL */
1422
1423     if (groups != NULL && groups[0] != '\0') {
1424         const char *cp;
1425         GETGROUPS_T *gids;
1426         int ngids;
1427
1428         /* Count number of groups, including passwd gid. */
1429         ngids = 2;
1430         for (cp = groups; *cp != '\0'; cp++) {
1431             if (*cp == ',')
1432                 ngids++;
1433         }
1434
1435         /* The first gid in the list is the passwd group gid. */
1436         gids = emalloc2(ngids, sizeof(GETGROUPS_T));
1437         gids[0] = user_gid;
1438         ngids = 1;
1439         cp = groups;
1440         for (;;) {
1441             gids[ngids] = atoi(cp);
1442             if (gids[0] != gids[ngids])
1443                 ngids++;
1444             cp = strchr(cp, ',');
1445             if (cp == NULL)
1446                 break;
1447             cp++; /* skip over comma */
1448         }
1449         user_gids = gids;
1450         user_ngids = ngids;
1451     }
1452
1453     /* Setup debugging if indicated. */
1454     if (debug_flags != NULL) {
1455         sudo_debug_init(NULL, debug_flags);
1456         for (cur = settings; *cur != NULL; cur++)
1457             sudo_debug_printf(SUDO_DEBUG_INFO, "settings: %s", *cur);
1458         for (cur = user_info; *cur != NULL; cur++)
1459             sudo_debug_printf(SUDO_DEBUG_INFO, "user_info: %s", *cur);
1460     }
1461
1462 #undef MATCHES
1463     debug_return_int(flags);
1464 }
1465
1466 static char *
1467 resolve_editor(char *editor, int nfiles, char **files, char ***argv_out)
1468 {
1469     char *cp, **nargv, *editor_path = NULL;
1470     int ac, i, nargc;
1471     bool wasblank;
1472     debug_decl(resolve_editor, SUDO_DEBUG_PLUGIN)
1473
1474     editor = estrdup(editor); /* becomes part of argv_out */
1475
1476     /*
1477      * Split editor into an argument vector; editor is reused (do not free).
1478      * The EDITOR and VISUAL environment variables may contain command
1479      * line args so look for those and alloc space for them too.
1480      */
1481     nargc = 1;
1482     for (wasblank = false, cp = editor; *cp != '\0'; cp++) {
1483         if (isblank((unsigned char) *cp))
1484             wasblank = true;
1485         else if (wasblank) {
1486             wasblank = false;
1487             nargc++;
1488         }
1489     }
1490     /* If we can't find the editor in the user's PATH, give up. */
1491     cp = strtok(editor, " \t");
1492     if (cp == NULL ||
1493         find_path(cp, &editor_path, NULL, getenv("PATH"), 0) != FOUND) {
1494         efree(editor);
1495         debug_return_str(NULL);
1496     }
1497     nargv = (char **) emalloc2(nargc + 1 + nfiles + 1, sizeof(char *));
1498     for (ac = 0; cp != NULL && ac < nargc; ac++) {
1499         nargv[ac] = cp;
1500         cp = strtok(NULL, " \t");
1501     }
1502     nargv[ac++] = "--";
1503     for (i = 0; i < nfiles; )
1504         nargv[ac++] = files[i++];
1505     nargv[ac] = NULL;
1506
1507     *argv_out = nargv;
1508     debug_return_str(editor_path);
1509 }
1510
1511 /*
1512  * Determine which editor to use.  We don't need to worry about restricting
1513  * this to a "safe" editor since it runs with the uid of the invoking user,
1514  * not the runas (privileged) user.
1515  */
1516 static char *
1517 find_editor(int nfiles, char **files, char ***argv_out)
1518 {
1519     char *cp, *editor, *editor_path = NULL, **ev, *ev0[4];
1520     debug_decl(find_editor, SUDO_DEBUG_PLUGIN)
1521
1522     /*
1523      * If any of SUDO_EDITOR, VISUAL or EDITOR are set, choose the first one.
1524      */
1525     ev0[0] = "SUDO_EDITOR";
1526     ev0[1] = "VISUAL";
1527     ev0[2] = "EDITOR";
1528     ev0[3] = NULL;
1529     for (ev = ev0; *ev != NULL; ev++) {
1530         if ((editor = getenv(*ev)) != NULL && *editor != '\0') {
1531             editor_path = resolve_editor(editor, nfiles, files, argv_out);
1532             if (editor_path != NULL)
1533                 break;
1534         }
1535     }
1536     if (editor_path == NULL) {
1537         /* def_editor could be a path, split it up */
1538         editor = estrdup(def_editor);
1539         cp = strtok(editor, ":");
1540         while (cp != NULL && editor_path == NULL) {
1541             editor_path = resolve_editor(cp, nfiles, files, argv_out);
1542             cp = strtok(NULL, ":");
1543         }
1544         if (editor_path)
1545             efree(editor);
1546     }
1547     if (!editor_path) {
1548         audit_failure(NewArgv, _("%s: command not found"), editor);
1549         warningx(_("%s: command not found"), editor);
1550     }
1551     debug_return_str(editor_path);
1552 }
1553
1554 #ifdef USE_ADMIN_FLAG
1555 static void
1556 create_admin_success_flag(void)
1557 {
1558     struct stat statbuf;
1559     char flagfile[PATH_MAX];
1560     int fd, n;
1561     debug_decl(create_admin_success_flag, SUDO_DEBUG_PLUGIN)
1562
1563     /* Check whether the user is in the admin group. */
1564     if (!user_in_group(sudo_user.pw, "admin"))
1565         debug_return;
1566
1567     /* Build path to flag file. */
1568     n = snprintf(flagfile, sizeof(flagfile), "%s/.sudo_as_admin_successful",
1569         user_dir);
1570     if (n <= 0 || n >= sizeof(flagfile))
1571         debug_return;
1572
1573     /* Create admin flag file if it doesn't already exist. */
1574     set_perms(PERM_USER);
1575     if (stat(flagfile, &statbuf) != 0) {
1576         fd = open(flagfile, O_CREAT|O_WRONLY|O_EXCL, 0644);
1577         close(fd);
1578     }
1579     restore_perms();
1580     debug_return;
1581 }
1582 #else /* !USE_ADMIN_FLAG */
1583 static void
1584 create_admin_success_flag(void)
1585 {
1586     /* STUB */
1587 }
1588 #endif /* USE_ADMIN_FLAG */
1589
1590 static void
1591 sudoers_policy_register_hooks(int version, int (*register_hook)(struct sudo_hook *hook))
1592 {
1593     struct sudo_hook hook;
1594
1595     memset(&hook, 0, sizeof(hook));
1596     hook.hook_version = SUDO_HOOK_VERSION;
1597
1598     hook.hook_type = SUDO_HOOK_SETENV;
1599     hook.hook_fn = sudoers_hook_setenv;
1600     register_hook(&hook);
1601
1602     hook.hook_type = SUDO_HOOK_UNSETENV;
1603     hook.hook_fn = sudoers_hook_unsetenv;
1604     register_hook(&hook);
1605
1606     hook.hook_type = SUDO_HOOK_GETENV;
1607     hook.hook_fn = sudoers_hook_getenv;
1608     register_hook(&hook);
1609
1610     hook.hook_type = SUDO_HOOK_PUTENV;
1611     hook.hook_fn = sudoers_hook_putenv;
1612     register_hook(&hook);
1613 }
1614
1615 __dso_public struct policy_plugin sudoers_policy = {
1616     SUDO_POLICY_PLUGIN,
1617     SUDO_API_VERSION,
1618     sudoers_policy_open,
1619     sudoers_policy_close,
1620     sudoers_policy_version,
1621     sudoers_policy_check,
1622     sudoers_policy_list,
1623     sudoers_policy_validate,
1624     sudoers_policy_invalidate,
1625     sudoers_policy_init_session,
1626     sudoers_policy_register_hooks
1627 };