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