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

   1 /*
   2  * Copyright (c) 1993-1996,1998-2005 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
  21 #include <config.h>
  22
  23 #include <sys/types.h>
  24 #include <sys/param.h>
  25 #include <sys/stat.h>
  26 #ifndef __TANDEM
  27 # include <sys/file.h>
  28 #endif
  29 #include <stdio.h>
  30 #ifdef STDC_HEADERS
  31 # include <stdlib.h>
  32 # include <stddef.h>
  33 #else
  34 # ifdef HAVE_STDLIB_H
  35 #  include <stdlib.h>
  36 # endif
  37 #endif /* STDC_HEADERS */
  38 #ifdef HAVE_STRING_H
  39 # include <string.h>
  40 #else
  41 # ifdef HAVE_STRINGS_H
  42 #  include <strings.h>
  43 # endif
  44 #endif /* HAVE_STRING_H */
  45 #ifdef HAVE_UNISTD_H
  46 # include <unistd.h>
  47 #endif /* HAVE_UNISTD_H */
  48 #ifdef HAVE_ERR_H
  49 # include <err.h>
  50 #else
  51 # include "emul/err.h"
  52 #endif /* HAVE_ERR_H */
  53 #include <errno.h>
  54 #include <fcntl.h>
  55 #include <signal.h>
  56 #include <time.h>
  57 #include <pwd.h>
  58 #include <grp.h>
  59 #ifndef HAVE_TIMESPEC
  60 # include <emul/timespec.h>
  61 #endif
  62
  63 #include "sudo.h"
  64
  65 #ifndef lint
  66 __unused static const char rcsid[] = "$Sudo: check.c,v 1.223.2.9 2007/07/06 19:52:13 millert Exp $";
  67 #endif /* lint */
  68
  69 /* Status codes for timestamp_status() */
  70 #define TS_CURRENT              0
  71 #define TS_OLD                  1
  72 #define TS_MISSING              2
  73 #define TS_NOFILE               3
  74 #define TS_ERROR                4
  75
  76 /* Flags for timestamp_status() */
  77 #define TS_MAKE_DIRS            1
  78 #define TS_REMOVE               2
  79
  80 static void  build_timestamp    __P((char **, char **));
  81 static int   timestamp_status   __P((char *, char *, char *, int));
  82 static char *expand_prompt      __P((char *, char *, char *));
  83 static void  lecture            __P((int));
  84 static void  update_timestamp   __P((char *, char *));
  85
  86 /*
  87  * This function only returns if the user can successfully
  88  * verify who he/she is.
  89  */
  90 void
  91 check_user(validated)
  92     int validated;
  93 {
  94     char *timestampdir = NULL;
  95     char *timestampfile = NULL;
  96     char *prompt;
  97     int status;
  98
  99     if (user_uid == 0 || user_uid == runas_pw->pw_uid || user_is_exempt())
 100         return;
 101
 102     build_timestamp(&timestampdir, &timestampfile);
 103     status = timestamp_status(timestampdir, timestampfile, user_name,
 104         TS_MAKE_DIRS);
 105     if (status != TS_CURRENT || ISSET(validated, FLAG_CHECK_USER)) {
 106         lecture(status);
 107
 108         /* Expand any escapes in the prompt. */
 109         prompt = expand_prompt(user_prompt ? user_prompt : def_passprompt,
 110             user_name, user_shost);
 111
 112         verify_user(auth_pw, prompt);
 113     }
 114     /* Only update timestamp if user was validated. */
 115     if (status != TS_ERROR && ISSET(validated, VALIDATE_OK))
 116         update_timestamp(timestampdir, timestampfile);
 117     efree(timestampdir);
 118     efree(timestampfile);
 119 }
 120
 121 /*
 122  * Standard sudo lecture.
 123  * TODO: allow the user to specify a file name instead.
 124  */
 125 static void
 126 lecture(status)
 127     int status;
 128 {
 129     FILE *fp;
 130     char buf[BUFSIZ];
 131     ssize_t nread;
 132
 133     if (def_lecture == never ||
 134         (def_lecture == once && status != TS_MISSING && status != TS_ERROR))
 135         return;
 136
 137     if (def_lecture_file && (fp = fopen(def_lecture_file, "r")) != NULL) {
 138         while ((nread = fread(buf, sizeof(char), sizeof(buf), fp)) != 0)
 139             fwrite(buf, nread, 1, stderr);
 140         fclose(fp);
 141     } else {
 142         (void) fputs("\n\
 143 We trust you have received the usual lecture from the local System\n\
 144 Administrator. It usually boils down to these three things:\n\
 145 \n\
 146     #1) Respect the privacy of others.\n\
 147     #2) Think before you type.\n\
 148     #3) With great power comes great responsibility.\n\n",
 149     stderr);
 150     }
 151 }
 152
 153 /*
 154  * Update the time on the timestamp file/dir or create it if necessary.
 155  */
 156 static void
 157 update_timestamp(timestampdir, timestampfile)
 158     char *timestampdir;
 159     char *timestampfile;
 160 {
 161     if (timestamp_uid != 0)
 162         set_perms(PERM_TIMESTAMP);
 163     if (touch(-1, timestampfile ? timestampfile : timestampdir, NULL) == -1) {
 164         if (timestampfile) {
 165             int fd = open(timestampfile, O_WRONLY|O_CREAT|O_TRUNC, 0600);
 166
 167             if (fd == -1)
 168                 log_error(NO_EXIT|USE_ERRNO, "Can't open %s", timestampfile);
 169             else
 170                 close(fd);
 171         } else {
 172             if (mkdir(timestampdir, 0700) == -1)
 173                 log_error(NO_EXIT|USE_ERRNO, "Can't mkdir %s", timestampdir);
 174         }
 175     }
 176     if (timestamp_uid != 0)
 177         set_perms(PERM_ROOT);
 178 }
 179
 180 /*
 181  * Expand %h and %u escapes in the prompt and pass back the dynamically
 182  * allocated result.  Returns the same string if there are no escapes.
 183  */
 184 static char *
 185 expand_prompt(old_prompt, user, host)
 186     char *old_prompt;
 187     char *user;
 188     char *host;
 189 {
 190     size_t len, n;
 191     int subst;
 192     char *p, *np, *new_prompt, *endp;
 193
 194     /* How much space do we need to malloc for the prompt? */
 195     subst = 0;
 196     for (p = old_prompt, len = strlen(old_prompt); *p; p++) {
 197         if (p[0] =='%') {
 198             switch (p[1]) {
 199                 case 'h':
 200                     p++;
 201                     len += strlen(user_shost) - 2;
 202                     subst = 1;
 203                     break;
 204                 case 'H':
 205                     p++;
 206                     len += strlen(user_host) - 2;
 207                     subst = 1;
 208                     break;
 209                 case 'u':
 210                     p++;
 211                     len += strlen(user_name) - 2;
 212                     subst = 1;
 213                     break;
 214                 case 'U':
 215                     p++;
 216                     len += strlen(*user_runas) - 2;
 217                     subst = 1;
 218                     break;
 219                 case 'p':
 220                         p++;
 221                         if (def_rootpw) {
 222                                 len += 2;
 223                         }
 224                         else if (def_targetpw || def_runaspw) {
 225                                 len += strlen(*user_runas) - 2;
 226                         }
 227                         else {
 228                                 len += strlen(user_name) - 2;
 229                         }
 230                         subst = 1;
 231                         break;
 232                 case '%':
 233                     p++;
 234                     len--;
 235                     subst = 1;
 236                     break;
 237                 default:
 238                     break;
 239             }
 240         }
 241     }
 242
 243     if (subst) {
 244         new_prompt = (char *) emalloc(++len);
 245         endp = new_prompt + len;
 246         for (p = old_prompt, np = new_prompt; *p; p++) {
 247             if (p[0] =='%') {
 248                 switch (p[1]) {
 249                     case 'h':
 250                         p++;
 251                         n = strlcpy(np, user_shost, np - endp);
 252                         if (n >= np - endp)
 253                             goto oflow;
 254                         np += n;
 255                         continue;
 256                     case 'H':
 257                         p++;
 258                         n = strlcpy(np, user_host, np - endp);
 259                         if (n >= np - endp)
 260                             goto oflow;
 261                         np += n;
 262                         continue;
 263                     case 'u':
 264                         p++;
 265                         n = strlcpy(np, user_name, np - endp);
 266                         if (n >= np - endp)
 267                             goto oflow;
 268                         np += n;
 269                         continue;
 270                     case 'U':
 271                         p++;
 272                         n = strlcpy(np,  *user_runas, np - endp);
 273                         if (n >= np - endp)
 274                             goto oflow;
 275                         np += n;
 276                         continue;
 277                         case 'p':
 278                         p++;
 279                         if (def_rootpw) {
 280                                 n = strlcpy(np, "root", np - endp);
 281                         }
 282                         else if (def_targetpw || def_runaspw) {
 283                                 n = strlcpy(np, *user_runas, np - endp);
 284                         }
 285                         else {
 286                                 n = strlcpy(np, user_name, np - endp);
 287                         }
 288                         if (n >= np - endp)
 289                                 goto oflow;
 290                         np += n;
 291                         continue;
 292                     case '%':
 293                         /* convert %% -> % */
 294                         p++;
 295                         break;
 296                     default:
 297                         /* no conversion */
 298                         break;
 299                 }
 300             }
 301             *np++ = *p;
 302             if (np >= endp)
 303                 goto oflow;
 304         }
 305         *np = '\0';
 306     } else
 307         new_prompt = old_prompt;
 308
 309     return(new_prompt);
 310
 311 oflow:
 312     /* We pre-allocate enough space, so this should never happen. */
 313     errx(1, "internal error, expand_prompt() overflow");
 314 }
 315
 316 /*
 317  * Checks if the user is exempt from supplying a password.
 318  */
 319 int
 320 user_is_exempt()
 321 {
 322     struct group *grp;
 323     char **gr_mem;
 324
 325     if (!def_exempt_group)
 326         return(FALSE);
 327
 328     if (!(grp = getgrnam(def_exempt_group)))
 329         return(FALSE);
 330
 331     if (user_gid == grp->gr_gid)
 332         return(TRUE);
 333
 334     for (gr_mem = grp->gr_mem; *gr_mem; gr_mem++) {
 335         if (strcmp(user_name, *gr_mem) == 0)
 336             return(TRUE);
 337     }
 338
 339     return(FALSE);
 340 }
 341
 342 /*
 343  * Fills in timestampdir as well as timestampfile if using tty tickets.
 344  */
 345 static void
 346 build_timestamp(timestampdir, timestampfile)
 347     char **timestampdir;
 348     char **timestampfile;
 349 {
 350     char *dirparent;
 351     int len;
 352
 353     dirparent = def_timestampdir;
 354     len = easprintf(timestampdir, "%s/%s", dirparent, user_name);
 355     if (len >= PATH_MAX)
 356         log_error(0, "timestamp path too long: %s", *timestampdir);
 357
 358     /*
 359      * Timestamp file may be a file in the directory or NUL to use
 360      * the directory as the timestamp.
 361      */
 362     if (def_tty_tickets) {
 363         char *p;
 364
 365         if ((p = strrchr(user_tty, '/')))
 366             p++;
 367         else
 368             p = user_tty;
 369         if (def_targetpw)
 370             len = easprintf(timestampfile, "%s/%s/%s:%s", dirparent, user_name,
 371                 p, *user_runas);
 372         else
 373             len = easprintf(timestampfile, "%s/%s/%s", dirparent, user_name, p);
 374         if (len >= PATH_MAX)
 375             log_error(0, "timestamp path too long: %s", *timestampfile);
 376     } else if (def_targetpw) {
 377         len = easprintf(timestampfile, "%s/%s/%s", dirparent, user_name,
 378             *user_runas);
 379         if (len >= PATH_MAX)
 380             log_error(0, "timestamp path too long: %s", *timestampfile);
 381     } else
 382         *timestampfile = NULL;
 383 }
 384
 385 /*
 386  * Check the timestamp file and directory and return their status.
 387  */
 388 static int
 389 timestamp_status(timestampdir, timestampfile, user, flags)
 390     char *timestampdir;
 391     char *timestampfile;
 392     char *user;
 393     int flags;
 394 {
 395     struct stat sb;
 396     time_t now;
 397     char *dirparent = def_timestampdir;
 398     int status = TS_ERROR;              /* assume the worst */
 399
 400     if (timestamp_uid != 0)
 401         set_perms(PERM_TIMESTAMP);
 402
 403     /*
 404      * Sanity check dirparent and make it if it doesn't already exist.
 405      * We start out assuming the worst (that the dir is not sane) and
 406      * if it is ok upgrade the status to ``no timestamp file''.
 407      * Note that we don't check the parent(s) of dirparent for
 408      * sanity since the sudo dir is often just located in /tmp.
 409      */
 410     if (lstat(dirparent, &sb) == 0) {
 411         if (!S_ISDIR(sb.st_mode))
 412             log_error(NO_EXIT, "%s exists but is not a directory (0%o)",
 413                 dirparent, (unsigned int) sb.st_mode);
 414         else if (sb.st_uid != timestamp_uid)
 415             log_error(NO_EXIT, "%s owned by uid %lu, should be uid %lu",
 416                 dirparent, (unsigned long) sb.st_uid,
 417                 (unsigned long) timestamp_uid);
 418         else if ((sb.st_mode & 0000022))
 419             log_error(NO_EXIT,
 420                 "%s writable by non-owner (0%o), should be mode 0700",
 421                 dirparent, (unsigned int) sb.st_mode);
 422         else {
 423             if ((sb.st_mode & 0000777) != 0700)
 424                 (void) chmod(dirparent, 0700);
 425             status = TS_MISSING;
 426         }
 427     } else if (errno != ENOENT) {
 428         log_error(NO_EXIT|USE_ERRNO, "can't stat %s", dirparent);
 429     } else {
 430         /* No dirparent, try to make one. */
 431         if (ISSET(flags, TS_MAKE_DIRS)) {
 432             if (mkdir(dirparent, S_IRWXU))
 433                 log_error(NO_EXIT|USE_ERRNO, "can't mkdir %s",
 434                     dirparent);
 435             else
 436                 status = TS_MISSING;
 437         }
 438     }
 439     if (status == TS_ERROR) {
 440         if (timestamp_uid != 0)
 441             set_perms(PERM_ROOT);
 442         return(status);
 443     }
 444
 445     /*
 446      * Sanity check the user's ticket dir.  We start by downgrading
 447      * the status to TS_ERROR.  If the ticket dir exists and is sane
 448      * this will be upgraded to TS_OLD.  If the dir does not exist,
 449      * it will be upgraded to TS_MISSING.
 450      */
 451     status = TS_ERROR;                  /* downgrade status again */
 452     if (lstat(timestampdir, &sb) == 0) {
 453         if (!S_ISDIR(sb.st_mode)) {
 454             if (S_ISREG(sb.st_mode)) {
 455                 /* convert from old style */
 456                 if (unlink(timestampdir) == 0)
 457                     status = TS_MISSING;
 458             } else
 459                 log_error(NO_EXIT, "%s exists but is not a directory (0%o)",
 460                     timestampdir, (unsigned int) sb.st_mode);
 461         } else if (sb.st_uid != timestamp_uid)
 462             log_error(NO_EXIT, "%s owned by uid %lu, should be uid %lu",
 463                 timestampdir, (unsigned long) sb.st_uid,
 464                 (unsigned long) timestamp_uid);
 465         else if ((sb.st_mode & 0000022))
 466             log_error(NO_EXIT,
 467                 "%s writable by non-owner (0%o), should be mode 0700",
 468                 timestampdir, (unsigned int) sb.st_mode);
 469         else {
 470             if ((sb.st_mode & 0000777) != 0700)
 471                 (void) chmod(timestampdir, 0700);
 472             status = TS_OLD;            /* do date check later */
 473         }
 474     } else if (errno != ENOENT) {
 475         log_error(NO_EXIT|USE_ERRNO, "can't stat %s", timestampdir);
 476     } else
 477         status = TS_MISSING;
 478
 479     /*
 480      * If there is no user ticket dir, AND we are in tty ticket mode,
 481      * AND the TS_MAKE_DIRS flag is set, create the user ticket dir.
 482      */
 483     if (status == TS_MISSING && timestampfile && ISSET(flags, TS_MAKE_DIRS)) {
 484         if (mkdir(timestampdir, S_IRWXU) == -1) {
 485             status = TS_ERROR;
 486             log_error(NO_EXIT|USE_ERRNO, "can't mkdir %s", timestampdir);
 487         }
 488     }
 489
 490     /*
 491      * Sanity check the tty ticket file if it exists.
 492      */
 493     if (timestampfile && status != TS_ERROR) {
 494         if (status != TS_MISSING)
 495             status = TS_NOFILE;                 /* dir there, file missing */
 496         if (lstat(timestampfile, &sb) == 0) {
 497             if (!S_ISREG(sb.st_mode)) {
 498                 status = TS_ERROR;
 499                 log_error(NO_EXIT, "%s exists but is not a regular file (0%o)",
 500                     timestampfile, (unsigned int) sb.st_mode);
 501             } else {
 502                 /* If bad uid or file mode, complain and kill the bogus file. */
 503                 if (sb.st_uid != timestamp_uid) {
 504                     log_error(NO_EXIT,
 505                         "%s owned by uid %lu, should be uid %lu",
 506                         timestampfile, (unsigned long) sb.st_uid,
 507                         (unsigned long) timestamp_uid);
 508                     (void) unlink(timestampfile);
 509                 } else if ((sb.st_mode & 0000022)) {
 510                     log_error(NO_EXIT,
 511                         "%s writable by non-owner (0%o), should be mode 0600",
 512                         timestampfile, (unsigned int) sb.st_mode);
 513                     (void) unlink(timestampfile);
 514                 } else {
 515                     /* If not mode 0600, fix it. */
 516                     if ((sb.st_mode & 0000777) != 0600)
 517                         (void) chmod(timestampfile, 0600);
 518
 519                     status = TS_OLD;    /* actually check mtime below */
 520                 }
 521             }
 522         } else if (errno != ENOENT) {
 523             log_error(NO_EXIT|USE_ERRNO, "can't stat %s", timestampfile);
 524             status = TS_ERROR;
 525         }
 526     }
 527
 528     /*
 529      * If the file/dir exists and we are not removing it, check its mtime.
 530      */
 531     if (status == TS_OLD && !ISSET(flags, TS_REMOVE)) {
 532         /* Negative timeouts only expire manually (sudo -k). */
 533         if (def_timestamp_timeout < 0 && sb.st_mtime != 0)
 534             status = TS_CURRENT;
 535         else {
 536             /* XXX - should use timespec here */
 537             now = time(NULL);
 538             if (def_timestamp_timeout &&
 539                 now - sb.st_mtime < 60 * def_timestamp_timeout) {
 540                 /*
 541                  * Check for bogus time on the stampfile.  The clock may
 542                  * have been set back or someone could be trying to spoof us.
 543                  */
 544                 if (sb.st_mtime > now + 60 * def_timestamp_timeout * 2) {
 545                     log_error(NO_EXIT,
 546                         "timestamp too far in the future: %20.20s",
 547                         4 + ctime(&sb.st_mtime));
 548                     if (timestampfile)
 549                         (void) unlink(timestampfile);
 550                     else
 551                         (void) rmdir(timestampdir);
 552                     status = TS_MISSING;
 553                 } else
 554                     status = TS_CURRENT;
 555             }
 556         }
 557     }
 558
 559     if (timestamp_uid != 0)
 560         set_perms(PERM_ROOT);
 561     return(status);
 562 }
 563
 564 /*
 565  * Remove the timestamp ticket file/dir.
 566  */
 567 void
 568 remove_timestamp(remove)
 569     int remove;
 570 {
 571     struct timespec ts;
 572     char *timestampdir, *timestampfile, *path;
 573     int status;
 574
 575     build_timestamp(&timestampdir, &timestampfile);
 576     status = timestamp_status(timestampdir, timestampfile, user_name,
 577         TS_REMOVE);
 578     if (status == TS_OLD || status == TS_CURRENT) {
 579         path = timestampfile ? timestampfile : timestampdir;
 580         if (remove) {
 581             if (timestampfile)
 582                 status = unlink(timestampfile);
 583             else
 584                 status = rmdir(timestampdir);
 585             if (status == -1 && errno != ENOENT) {
 586                 log_error(NO_EXIT, "can't remove %s (%s), will reset to Epoch",
 587                     path, strerror(errno));
 588                 remove = FALSE;
 589             }
 590         } else {
 591             timespecclear(&ts);
 592             if (touch(-1, path, &ts) == -1)
 593                 err(1, "can't reset %s to Epoch", path);
 594         }
 595     }
 596
 597     efree(timestampdir);
 598     efree(timestampfile);
 599 }