Annotation of embedaddon/sudo/plugins/sudoers/check.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 1993-1996,1998-2005, 2007-2011
! 3: * Todd C. Miller <Todd.Miller@courtesan.com>
! 4: *
! 5: * Permission to use, copy, modify, and distribute this software for any
! 6: * purpose with or without fee is hereby granted, provided that the above
! 7: * copyright notice and this permission notice appear in all copies.
! 8: *
! 9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 16: *
! 17: * Sponsored in part by the Defense Advanced Research Projects
! 18: * Agency (DARPA) and Air Force Research Laboratory, Air Force
! 19: * Materiel Command, USAF, under agreement number F39502-99-1-0512.
! 20: */
! 21:
! 22: #include <config.h>
! 23:
! 24: #include <sys/types.h>
! 25: #include <sys/param.h>
! 26: #include <sys/time.h>
! 27: #include <sys/stat.h>
! 28: #ifdef __linux__
! 29: # include <sys/vfs.h>
! 30: #endif
! 31: #if defined(__sun) && defined(__SVR4)
! 32: # include <sys/statvfs.h>
! 33: #endif
! 34: #ifndef __TANDEM
! 35: # include <sys/file.h>
! 36: #endif
! 37: #include <stdio.h>
! 38: #ifdef STDC_HEADERS
! 39: # include <stdlib.h>
! 40: # include <stddef.h>
! 41: #else
! 42: # ifdef HAVE_STDLIB_H
! 43: # include <stdlib.h>
! 44: # endif
! 45: #endif /* STDC_HEADERS */
! 46: #ifdef HAVE_STRING_H
! 47: # include <string.h>
! 48: #endif /* HAVE_STRING_H */
! 49: #ifdef HAVE_STRINGS_H
! 50: # include <strings.h>
! 51: #endif /* HAVE_STRINGS_H */
! 52: #ifdef HAVE_UNISTD_H
! 53: # include <unistd.h>
! 54: #endif /* HAVE_UNISTD_H */
! 55: #if TIME_WITH_SYS_TIME
! 56: # include <time.h>
! 57: #endif
! 58: #include <errno.h>
! 59: #include <fcntl.h>
! 60: #include <signal.h>
! 61: #include <pwd.h>
! 62: #include <grp.h>
! 63:
! 64: #include "sudoers.h"
! 65:
! 66: /* Status codes for timestamp_status() */
! 67: #define TS_CURRENT 0
! 68: #define TS_OLD 1
! 69: #define TS_MISSING 2
! 70: #define TS_NOFILE 3
! 71: #define TS_ERROR 4
! 72:
! 73: /* Flags for timestamp_status() */
! 74: #define TS_MAKE_DIRS 1
! 75: #define TS_REMOVE 2
! 76:
! 77: /*
! 78: * Info stored in tty ticket from stat(2) to help with tty matching.
! 79: */
! 80: static struct tty_info {
! 81: dev_t dev; /* ID of device tty resides on */
! 82: dev_t rdev; /* tty device ID */
! 83: ino_t ino; /* tty inode number */
! 84: struct timeval ctime; /* tty inode change time */
! 85: } tty_info;
! 86:
! 87: static int build_timestamp(char **, char **);
! 88: static int timestamp_status(char *, char *, char *, int);
! 89: static char *expand_prompt(char *, char *, char *);
! 90: static void lecture(int);
! 91: static void update_timestamp(char *, char *);
! 92: static int tty_is_devpts(const char *);
! 93: static struct passwd *get_authpw(void);
! 94:
! 95: /*
! 96: * Returns TRUE if the user successfully authenticates, else FALSE.
! 97: */
! 98: int
! 99: check_user(int validated, int mode)
! 100: {
! 101: struct passwd *auth_pw;
! 102: char *timestampdir = NULL;
! 103: char *timestampfile = NULL;
! 104: char *prompt;
! 105: struct stat sb;
! 106: int status, rval = TRUE;
! 107: int need_pass = def_authenticate;
! 108:
! 109: /*
! 110: * Init authentication system regardless of whether we need a password.
! 111: * Required for proper PAM session support.
! 112: */
! 113: auth_pw = get_authpw();
! 114: if (sudo_auth_init(auth_pw) == -1) {
! 115: rval = -1;
! 116: goto done;
! 117: }
! 118:
! 119: if (need_pass) {
! 120: /* Always need a password when -k was specified with the command. */
! 121: if (ISSET(mode, MODE_IGNORE_TICKET)) {
! 122: SET(validated, FLAG_CHECK_USER);
! 123: } else {
! 124: /*
! 125: * Don't prompt for the root passwd or if the user is exempt.
! 126: * If the user is not changing uid/gid, no need for a password.
! 127: */
! 128: if (user_uid == 0 || (user_uid == runas_pw->pw_uid &&
! 129: (!runas_gr || user_in_group(sudo_user.pw, runas_gr->gr_name)))
! 130: || user_is_exempt())
! 131: need_pass = FALSE;
! 132: }
! 133: }
! 134: if (!need_pass)
! 135: goto done;
! 136:
! 137: /* Stash the tty's ctime for tty ticket comparison. */
! 138: if (def_tty_tickets && user_ttypath && stat(user_ttypath, &sb) == 0) {
! 139: tty_info.dev = sb.st_dev;
! 140: tty_info.ino = sb.st_ino;
! 141: tty_info.rdev = sb.st_rdev;
! 142: if (tty_is_devpts(user_ttypath))
! 143: ctim_get(&sb, &tty_info.ctime);
! 144: }
! 145:
! 146: if (build_timestamp(×tampdir, ×tampfile) == -1) {
! 147: rval = -1;
! 148: goto done;
! 149: }
! 150:
! 151: status = timestamp_status(timestampdir, timestampfile, user_name,
! 152: TS_MAKE_DIRS);
! 153:
! 154: if (status != TS_CURRENT || ISSET(validated, FLAG_CHECK_USER)) {
! 155: /* Bail out if we are non-interactive and a password is required */
! 156: if (ISSET(mode, MODE_NONINTERACTIVE)) {
! 157: warningx(_("sorry, a password is required to run %s"), getprogname());
! 158: rval = -1;
! 159: goto done;
! 160: }
! 161:
! 162: /* XXX - should not lecture if askpass helper is being used. */
! 163: lecture(status);
! 164:
! 165: /* Expand any escapes in the prompt. */
! 166: prompt = expand_prompt(user_prompt ? user_prompt : def_passprompt,
! 167: user_name, user_shost);
! 168:
! 169: rval = verify_user(auth_pw, prompt);
! 170: }
! 171: /* Only update timestamp if user was validated. */
! 172: if (rval == TRUE && ISSET(validated, VALIDATE_OK) &&
! 173: !ISSET(mode, MODE_IGNORE_TICKET) && status != TS_ERROR)
! 174: update_timestamp(timestampdir, timestampfile);
! 175: efree(timestampdir);
! 176: efree(timestampfile);
! 177:
! 178: done:
! 179: sudo_auth_cleanup(auth_pw);
! 180: pw_delref(auth_pw);
! 181:
! 182: return rval;
! 183: }
! 184:
! 185: #define DEFAULT_LECTURE "\n" \
! 186: "We trust you have received the usual lecture from the local System\n" \
! 187: "Administrator. It usually boils down to these three things:\n\n" \
! 188: " #1) Respect the privacy of others.\n" \
! 189: " #2) Think before you type.\n" \
! 190: " #3) With great power comes great responsibility.\n\n"
! 191:
! 192: /*
! 193: * Standard sudo lecture.
! 194: */
! 195: static void
! 196: lecture(int status)
! 197: {
! 198: FILE *fp;
! 199: char buf[BUFSIZ];
! 200: ssize_t nread;
! 201: struct sudo_conv_message msg;
! 202: struct sudo_conv_reply repl;
! 203:
! 204: if (def_lecture == never ||
! 205: (def_lecture == once && status != TS_MISSING && status != TS_ERROR))
! 206: return;
! 207:
! 208: memset(&msg, 0, sizeof(msg));
! 209: memset(&repl, 0, sizeof(repl));
! 210:
! 211: if (def_lecture_file && (fp = fopen(def_lecture_file, "r")) != NULL) {
! 212: while ((nread = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) != 0) {
! 213: buf[sizeof(buf) - 1] = '\0';
! 214: msg.msg_type = SUDO_CONV_ERROR_MSG;
! 215: msg.msg = buf;
! 216: sudo_conv(1, &msg, &repl);
! 217: }
! 218: fclose(fp);
! 219: } else {
! 220: msg.msg_type = SUDO_CONV_ERROR_MSG;
! 221: msg.msg = _(DEFAULT_LECTURE);
! 222: sudo_conv(1, &msg, &repl);
! 223: }
! 224: }
! 225:
! 226: /*
! 227: * Update the time on the timestamp file/dir or create it if necessary.
! 228: */
! 229: static void
! 230: update_timestamp(char *timestampdir, char *timestampfile)
! 231: {
! 232: /* If using tty timestamps but we have no tty there is nothing to do. */
! 233: if (def_tty_tickets && !user_ttypath)
! 234: return;
! 235:
! 236: if (timestamp_uid != 0)
! 237: set_perms(PERM_TIMESTAMP);
! 238: if (timestampfile) {
! 239: /*
! 240: * Store tty info in timestamp file
! 241: */
! 242: int fd = open(timestampfile, O_WRONLY|O_CREAT, 0600);
! 243: if (fd == -1)
! 244: log_error(NO_EXIT|USE_ERRNO, _("unable to open %s"), timestampfile);
! 245: else {
! 246: lock_file(fd, SUDO_LOCK);
! 247: if (write(fd, &tty_info, sizeof(tty_info)) != sizeof(tty_info)) {
! 248: log_error(NO_EXIT|USE_ERRNO, _("unable to write to %s"),
! 249: timestampfile);
! 250: }
! 251: close(fd);
! 252: }
! 253: } else {
! 254: if (touch(-1, timestampdir, NULL) == -1) {
! 255: if (mkdir(timestampdir, 0700) == -1) {
! 256: log_error(NO_EXIT|USE_ERRNO, _("unable to mkdir %s"),
! 257: timestampdir);
! 258: }
! 259: }
! 260: }
! 261: if (timestamp_uid != 0)
! 262: restore_perms();
! 263: }
! 264:
! 265: /*
! 266: * Expand %h and %u escapes in the prompt and pass back the dynamically
! 267: * allocated result. Returns the same string if there are no escapes.
! 268: */
! 269: static char *
! 270: expand_prompt(char *old_prompt, char *user, char *host)
! 271: {
! 272: size_t len, n;
! 273: int subst;
! 274: char *p, *np, *new_prompt, *endp;
! 275:
! 276: /* How much space do we need to malloc for the prompt? */
! 277: subst = 0;
! 278: for (p = old_prompt, len = strlen(old_prompt); *p; p++) {
! 279: if (p[0] =='%') {
! 280: switch (p[1]) {
! 281: case 'h':
! 282: p++;
! 283: len += strlen(user_shost) - 2;
! 284: subst = 1;
! 285: break;
! 286: case 'H':
! 287: p++;
! 288: len += strlen(user_host) - 2;
! 289: subst = 1;
! 290: break;
! 291: case 'p':
! 292: p++;
! 293: if (def_rootpw)
! 294: len += 2;
! 295: else if (def_targetpw || def_runaspw)
! 296: len += strlen(runas_pw->pw_name) - 2;
! 297: else
! 298: len += strlen(user_name) - 2;
! 299: subst = 1;
! 300: break;
! 301: case 'u':
! 302: p++;
! 303: len += strlen(user_name) - 2;
! 304: subst = 1;
! 305: break;
! 306: case 'U':
! 307: p++;
! 308: len += strlen(runas_pw->pw_name) - 2;
! 309: subst = 1;
! 310: break;
! 311: case '%':
! 312: p++;
! 313: len--;
! 314: subst = 1;
! 315: break;
! 316: default:
! 317: break;
! 318: }
! 319: }
! 320: }
! 321:
! 322: if (subst) {
! 323: new_prompt = emalloc(++len);
! 324: endp = new_prompt + len;
! 325: for (p = old_prompt, np = new_prompt; *p; p++) {
! 326: if (p[0] =='%') {
! 327: switch (p[1]) {
! 328: case 'h':
! 329: p++;
! 330: n = strlcpy(np, user_shost, np - endp);
! 331: if (n >= np - endp)
! 332: goto oflow;
! 333: np += n;
! 334: continue;
! 335: case 'H':
! 336: p++;
! 337: n = strlcpy(np, user_host, np - endp);
! 338: if (n >= np - endp)
! 339: goto oflow;
! 340: np += n;
! 341: continue;
! 342: case 'p':
! 343: p++;
! 344: if (def_rootpw)
! 345: n = strlcpy(np, "root", np - endp);
! 346: else if (def_targetpw || def_runaspw)
! 347: n = strlcpy(np, runas_pw->pw_name, np - endp);
! 348: else
! 349: n = strlcpy(np, user_name, np - endp);
! 350: if (n >= np - endp)
! 351: goto oflow;
! 352: np += n;
! 353: continue;
! 354: case 'u':
! 355: p++;
! 356: n = strlcpy(np, user_name, np - endp);
! 357: if (n >= np - endp)
! 358: goto oflow;
! 359: np += n;
! 360: continue;
! 361: case 'U':
! 362: p++;
! 363: n = strlcpy(np, runas_pw->pw_name, np - endp);
! 364: if (n >= np - endp)
! 365: goto oflow;
! 366: np += n;
! 367: continue;
! 368: case '%':
! 369: /* convert %% -> % */
! 370: p++;
! 371: break;
! 372: default:
! 373: /* no conversion */
! 374: break;
! 375: }
! 376: }
! 377: *np++ = *p;
! 378: if (np >= endp)
! 379: goto oflow;
! 380: }
! 381: *np = '\0';
! 382: } else
! 383: new_prompt = old_prompt;
! 384:
! 385: return new_prompt;
! 386:
! 387: oflow:
! 388: /* We pre-allocate enough space, so this should never happen. */
! 389: errorx(1, _("internal error, expand_prompt() overflow"));
! 390: }
! 391:
! 392: /*
! 393: * Checks if the user is exempt from supplying a password.
! 394: */
! 395: int
! 396: user_is_exempt(void)
! 397: {
! 398: if (!def_exempt_group)
! 399: return FALSE;
! 400: return user_in_group(sudo_user.pw, def_exempt_group);
! 401: }
! 402:
! 403: /*
! 404: * Fills in timestampdir as well as timestampfile if using tty tickets.
! 405: */
! 406: static int
! 407: build_timestamp(char **timestampdir, char **timestampfile)
! 408: {
! 409: char *dirparent;
! 410: int len;
! 411:
! 412: dirparent = def_timestampdir;
! 413: len = easprintf(timestampdir, "%s/%s", dirparent, user_name);
! 414: if (len >= PATH_MAX)
! 415: goto bad;
! 416:
! 417: /*
! 418: * Timestamp file may be a file in the directory or NUL to use
! 419: * the directory as the timestamp.
! 420: */
! 421: if (def_tty_tickets) {
! 422: char *p;
! 423:
! 424: if ((p = strrchr(user_tty, '/')))
! 425: p++;
! 426: else
! 427: p = user_tty;
! 428: if (def_targetpw)
! 429: len = easprintf(timestampfile, "%s/%s/%s:%s", dirparent, user_name,
! 430: p, runas_pw->pw_name);
! 431: else
! 432: len = easprintf(timestampfile, "%s/%s/%s", dirparent, user_name, p);
! 433: if (len >= PATH_MAX)
! 434: goto bad;
! 435: } else if (def_targetpw) {
! 436: len = easprintf(timestampfile, "%s/%s/%s", dirparent, user_name,
! 437: runas_pw->pw_name);
! 438: if (len >= PATH_MAX)
! 439: goto bad;
! 440: } else
! 441: *timestampfile = NULL;
! 442:
! 443: return len;
! 444: bad:
! 445: log_error(0, _("timestamp path too long: %s"), *timestampfile);
! 446: return -1;
! 447: }
! 448:
! 449: /*
! 450: * Check the timestamp file and directory and return their status.
! 451: */
! 452: static int
! 453: timestamp_status(char *timestampdir, char *timestampfile, char *user, int flags)
! 454: {
! 455: struct stat sb;
! 456: struct timeval boottime, mtime;
! 457: time_t now;
! 458: char *dirparent = def_timestampdir;
! 459: int status = TS_ERROR; /* assume the worst */
! 460:
! 461: if (timestamp_uid != 0)
! 462: set_perms(PERM_TIMESTAMP);
! 463:
! 464: /*
! 465: * Sanity check dirparent and make it if it doesn't already exist.
! 466: * We start out assuming the worst (that the dir is not sane) and
! 467: * if it is ok upgrade the status to ``no timestamp file''.
! 468: * Note that we don't check the parent(s) of dirparent for
! 469: * sanity since the sudo dir is often just located in /tmp.
! 470: */
! 471: if (lstat(dirparent, &sb) == 0) {
! 472: if (!S_ISDIR(sb.st_mode))
! 473: log_error(NO_EXIT, _("%s exists but is not a directory (0%o)"),
! 474: dirparent, (unsigned int) sb.st_mode);
! 475: else if (sb.st_uid != timestamp_uid)
! 476: log_error(NO_EXIT, _("%s owned by uid %u, should be uid %u"),
! 477: dirparent, (unsigned int) sb.st_uid,
! 478: (unsigned int) timestamp_uid);
! 479: else if ((sb.st_mode & 0000022))
! 480: log_error(NO_EXIT,
! 481: _("%s writable by non-owner (0%o), should be mode 0700"),
! 482: dirparent, (unsigned int) sb.st_mode);
! 483: else {
! 484: if ((sb.st_mode & 0000777) != 0700)
! 485: (void) chmod(dirparent, 0700);
! 486: status = TS_MISSING;
! 487: }
! 488: } else if (errno != ENOENT) {
! 489: log_error(NO_EXIT|USE_ERRNO, _("unable to stat %s"), dirparent);
! 490: } else {
! 491: /* No dirparent, try to make one. */
! 492: if (ISSET(flags, TS_MAKE_DIRS)) {
! 493: if (mkdir(dirparent, S_IRWXU))
! 494: log_error(NO_EXIT|USE_ERRNO, _("unable to mkdir %s"),
! 495: dirparent);
! 496: else
! 497: status = TS_MISSING;
! 498: }
! 499: }
! 500: if (status == TS_ERROR)
! 501: goto done;
! 502:
! 503: /*
! 504: * Sanity check the user's ticket dir. We start by downgrading
! 505: * the status to TS_ERROR. If the ticket dir exists and is sane
! 506: * this will be upgraded to TS_OLD. If the dir does not exist,
! 507: * it will be upgraded to TS_MISSING.
! 508: */
! 509: status = TS_ERROR; /* downgrade status again */
! 510: if (lstat(timestampdir, &sb) == 0) {
! 511: if (!S_ISDIR(sb.st_mode)) {
! 512: if (S_ISREG(sb.st_mode)) {
! 513: /* convert from old style */
! 514: if (unlink(timestampdir) == 0)
! 515: status = TS_MISSING;
! 516: } else
! 517: log_error(NO_EXIT, _("%s exists but is not a directory (0%o)"),
! 518: timestampdir, (unsigned int) sb.st_mode);
! 519: } else if (sb.st_uid != timestamp_uid)
! 520: log_error(NO_EXIT, _("%s owned by uid %u, should be uid %u"),
! 521: timestampdir, (unsigned int) sb.st_uid,
! 522: (unsigned int) timestamp_uid);
! 523: else if ((sb.st_mode & 0000022))
! 524: log_error(NO_EXIT,
! 525: _("%s writable by non-owner (0%o), should be mode 0700"),
! 526: timestampdir, (unsigned int) sb.st_mode);
! 527: else {
! 528: if ((sb.st_mode & 0000777) != 0700)
! 529: (void) chmod(timestampdir, 0700);
! 530: status = TS_OLD; /* do date check later */
! 531: }
! 532: } else if (errno != ENOENT) {
! 533: log_error(NO_EXIT|USE_ERRNO, _("unable to stat %s"), timestampdir);
! 534: } else
! 535: status = TS_MISSING;
! 536:
! 537: /*
! 538: * If there is no user ticket dir, AND we are in tty ticket mode,
! 539: * AND the TS_MAKE_DIRS flag is set, create the user ticket dir.
! 540: */
! 541: if (status == TS_MISSING && timestampfile && ISSET(flags, TS_MAKE_DIRS)) {
! 542: if (mkdir(timestampdir, S_IRWXU) == -1) {
! 543: status = TS_ERROR;
! 544: log_error(NO_EXIT|USE_ERRNO, _("unable to mkdir %s"), timestampdir);
! 545: }
! 546: }
! 547:
! 548: /*
! 549: * Sanity check the tty ticket file if it exists.
! 550: */
! 551: if (timestampfile && status != TS_ERROR) {
! 552: if (status != TS_MISSING)
! 553: status = TS_NOFILE; /* dir there, file missing */
! 554: if (def_tty_tickets && !user_ttypath)
! 555: goto done; /* no tty, always prompt */
! 556: if (lstat(timestampfile, &sb) == 0) {
! 557: if (!S_ISREG(sb.st_mode)) {
! 558: status = TS_ERROR;
! 559: log_error(NO_EXIT, _("%s exists but is not a regular file (0%o)"),
! 560: timestampfile, (unsigned int) sb.st_mode);
! 561: } else {
! 562: /* If bad uid or file mode, complain and kill the bogus file. */
! 563: if (sb.st_uid != timestamp_uid) {
! 564: log_error(NO_EXIT,
! 565: _("%s owned by uid %u, should be uid %u"),
! 566: timestampfile, (unsigned int) sb.st_uid,
! 567: (unsigned int) timestamp_uid);
! 568: (void) unlink(timestampfile);
! 569: } else if ((sb.st_mode & 0000022)) {
! 570: log_error(NO_EXIT,
! 571: _("%s writable by non-owner (0%o), should be mode 0600"),
! 572: timestampfile, (unsigned int) sb.st_mode);
! 573: (void) unlink(timestampfile);
! 574: } else {
! 575: /* If not mode 0600, fix it. */
! 576: if ((sb.st_mode & 0000777) != 0600)
! 577: (void) chmod(timestampfile, 0600);
! 578:
! 579: /*
! 580: * Check for stored tty info. If the file is zero-sized
! 581: * it is an old-style timestamp with no tty info in it.
! 582: * If removing, we don't care about the contents.
! 583: * The actual mtime check is done later.
! 584: */
! 585: if (ISSET(flags, TS_REMOVE)) {
! 586: status = TS_OLD;
! 587: } else if (sb.st_size != 0) {
! 588: struct tty_info info;
! 589: int fd = open(timestampfile, O_RDONLY, 0644);
! 590: if (fd != -1) {
! 591: if (read(fd, &info, sizeof(info)) == sizeof(info) &&
! 592: memcmp(&info, &tty_info, sizeof(info)) == 0) {
! 593: status = TS_OLD;
! 594: }
! 595: close(fd);
! 596: }
! 597: }
! 598: }
! 599: }
! 600: } else if (errno != ENOENT) {
! 601: log_error(NO_EXIT|USE_ERRNO, _("unable to stat %s"), timestampfile);
! 602: status = TS_ERROR;
! 603: }
! 604: }
! 605:
! 606: /*
! 607: * If the file/dir exists and we are not removing it, check its mtime.
! 608: */
! 609: if (status == TS_OLD && !ISSET(flags, TS_REMOVE)) {
! 610: mtim_get(&sb, &mtime);
! 611: /* Negative timeouts only expire manually (sudo -k). */
! 612: if (def_timestamp_timeout < 0 && mtime.tv_sec != 0)
! 613: status = TS_CURRENT;
! 614: else {
! 615: now = time(NULL);
! 616: if (def_timestamp_timeout &&
! 617: now - mtime.tv_sec < 60 * def_timestamp_timeout) {
! 618: /*
! 619: * Check for bogus time on the stampfile. The clock may
! 620: * have been set back or someone could be trying to spoof us.
! 621: */
! 622: if (mtime.tv_sec > now + 60 * def_timestamp_timeout * 2) {
! 623: time_t tv_sec = (time_t)mtime.tv_sec;
! 624: log_error(NO_EXIT,
! 625: _("timestamp too far in the future: %20.20s"),
! 626: 4 + ctime(&tv_sec));
! 627: if (timestampfile)
! 628: (void) unlink(timestampfile);
! 629: else
! 630: (void) rmdir(timestampdir);
! 631: status = TS_MISSING;
! 632: } else if (get_boottime(&boottime) && timevalcmp(&mtime, &boottime, <)) {
! 633: status = TS_OLD;
! 634: } else {
! 635: status = TS_CURRENT;
! 636: }
! 637: }
! 638: }
! 639: }
! 640:
! 641: done:
! 642: if (timestamp_uid != 0)
! 643: restore_perms();
! 644: return status;
! 645: }
! 646:
! 647: /*
! 648: * Remove the timestamp ticket file/dir.
! 649: */
! 650: void
! 651: remove_timestamp(int remove)
! 652: {
! 653: struct timeval tv;
! 654: char *timestampdir, *timestampfile, *path;
! 655: int status;
! 656:
! 657: if (build_timestamp(×tampdir, ×tampfile) == -1)
! 658: return;
! 659:
! 660: status = timestamp_status(timestampdir, timestampfile, user_name,
! 661: TS_REMOVE);
! 662: if (status != TS_MISSING && status != TS_ERROR) {
! 663: path = timestampfile ? timestampfile : timestampdir;
! 664: if (remove) {
! 665: if (timestampfile)
! 666: status = unlink(timestampfile);
! 667: else
! 668: status = rmdir(timestampdir);
! 669: if (status == -1 && errno != ENOENT) {
! 670: log_error(NO_EXIT,
! 671: _("unable to remove %s (%s), will reset to the epoch"),
! 672: path, strerror(errno));
! 673: remove = FALSE;
! 674: }
! 675: }
! 676: if (!remove) {
! 677: timevalclear(&tv);
! 678: if (touch(-1, path, &tv) == -1 && errno != ENOENT)
! 679: error(1, _("unable to reset %s to the epoch"), path);
! 680: }
! 681: }
! 682:
! 683: efree(timestampdir);
! 684: efree(timestampfile);
! 685: }
! 686:
! 687: /*
! 688: * Returns TRUE if tty lives on a devpts or /devices filesystem, else FALSE.
! 689: * Unlike most filesystems, the ctime of devpts nodes is not updated when
! 690: * the device node is written to, only when the inode's status changes,
! 691: * typically via the chmod, chown, link, rename, or utimes system calls.
! 692: * Since the ctime is "stable" in this case, we can stash it the tty ticket
! 693: * file and use it to determine whether the tty ticket file is stale.
! 694: */
! 695: static int
! 696: tty_is_devpts(const char *tty)
! 697: {
! 698: int retval = FALSE;
! 699: #ifdef __linux__
! 700: struct statfs sfs;
! 701:
! 702: #ifndef DEVPTS_SUPER_MAGIC
! 703: # define DEVPTS_SUPER_MAGIC 0x1cd1
! 704: #endif
! 705:
! 706: if (statfs(tty, &sfs) == 0) {
! 707: if (sfs.f_type == DEVPTS_SUPER_MAGIC)
! 708: retval = TRUE;
! 709: }
! 710: #elif defined(__sun) && defined(__SVR4)
! 711: struct statvfs sfs;
! 712:
! 713: if (statvfs(tty, &sfs) == 0) {
! 714: if (strcmp(sfs.f_fstr, "devices") == 0)
! 715: retval = TRUE;
! 716: }
! 717: #endif /* __linux__ */
! 718: return retval;
! 719: }
! 720:
! 721: /*
! 722: * Get passwd entry for the user we are going to authenticate as.
! 723: * By default, this is the user invoking sudo. In the most common
! 724: * case, this matches sudo_user.pw or runas_pw.
! 725: */
! 726: static struct passwd *
! 727: get_authpw(void)
! 728: {
! 729: struct passwd *pw;
! 730:
! 731: if (def_rootpw) {
! 732: if ((pw = sudo_getpwuid(ROOT_UID)) == NULL)
! 733: log_error(0, _("unknown uid: %u"), ROOT_UID);
! 734: } else if (def_runaspw) {
! 735: if ((pw = sudo_getpwnam(def_runas_default)) == NULL)
! 736: log_error(0, _("unknown user: %s"), def_runas_default);
! 737: } else if (def_targetpw) {
! 738: if (runas_pw->pw_name == NULL)
! 739: log_error(NO_MAIL|MSG_ONLY, _("unknown uid: %u"),
! 740: (unsigned int) runas_pw->pw_uid);
! 741: pw_addref(runas_pw);
! 742: pw = runas_pw;
! 743: } else {
! 744: pw_addref(sudo_user.pw);
! 745: pw = sudo_user.pw;
! 746: }
! 747:
! 748: return pw;
! 749: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to check.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