modules/pam_succeed_if/pam_succeed_if.c

   1 /******************************************************************************
   2  * A simple user-attribute based module for PAM.
   3  *
   4  * Copyright (c) 2003 Red Hat, Inc.
   5  * Written by Nalin Dahyabhai <nalin@redhat.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, and the entire permission notice in its entirety,
  12  *    including the disclaimer of warranties.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote
  17  *    products derived from this software without specific prior
  18  *    written permission.
  19  *
  20  * ALTERNATIVELY, this product may be distributed under the terms of
  21  * the GNU Public License, in which case the provisions of the GPL are
  22  * required INSTEAD OF the above restrictions.  (This clause is
  23  * necessary due to a potential bad interaction between the GPL and
  24  * the restrictions contained in a BSD-style copyright.)
  25  *
  26  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  27  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  29  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  30  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  31  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  32  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  34  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  36  * OF THE POSSIBILITY OF SUCH DAMAGE.
  37  *
  38  */
  39
  40 #include "config.h"
  41
  42 #include <sys/types.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <fnmatch.h>
  46 #include <limits.h>
  47 #include <stdarg.h>
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <syslog.h>
  52 #include <unistd.h>
  53 #include <pwd.h>
  54 #include <grp.h>
  55 #include <netdb.h>
  56
  57 #define PAM_SM_AUTH
  58 #define PAM_SM_ACCOUNT
  59 #define PAM_SM_SESSION
  60 #define PAM_SM_PASSWORD
  61
  62 #include <security/pam_modules.h>
  63 #include <security/pam_modutil.h>
  64 #include <security/pam_ext.h>
  65
  66 /* Basically, run cmp(atol(left), atol(right)), returning PAM_SUCCESS if
  67  * the function returns non-zero, PAM_AUTH_ERR if it returns zero, and
  68  * PAM_SERVICE_ERR if the arguments can't be parsed as numbers. */
  69 static int
  70 evaluate_num(const pam_handle_t *pamh, const char *left,
  71              const char *right, int (*cmp)(int, int))
  72 {
  73         long l, r;
  74         char *p;
  75         int ret = PAM_SUCCESS;
  76
  77         errno = 0;
  78         l = strtol(left, &p, 0);
  79         if ((p == NULL) || (*p != '\0') || errno) {
  80                 pam_syslog(pamh, LOG_INFO, "\"%s\" is not a number", left);
  81                 ret = PAM_SERVICE_ERR;
  82         }
  83
  84         r = strtol(right, &p, 0);
  85         if ((p == NULL) || (*p != '\0') || errno) {
  86                 pam_syslog(pamh, LOG_INFO, "\"%s\" is not a number", right);
  87                 ret = PAM_SERVICE_ERR;
  88         }
  89
  90         if (ret != PAM_SUCCESS) {
  91                 return ret;
  92         }
  93
  94         return cmp(l, r) ? PAM_SUCCESS : PAM_AUTH_ERR;
  95 }
  96
  97 /* Simple numeric comparison callbacks. */
  98 static int
  99 eq(int i, int j)
 100 {
 101         return i == j;
 102 }
 103 static int
 104 ne(int i, int j)
 105 {
 106         return i != j;
 107 }
 108 static int
 109 lt(int i, int j)
 110 {
 111         return i < j;
 112 }
 113 static int
 114 le(int i, int j)
 115 {
 116         return lt(i, j) || eq(i, j);
 117 }
 118 static int
 119 gt(int i, int j)
 120 {
 121         return i > j;
 122 }
 123 static int
 124 ge(int i, int j)
 125 {
 126         return gt(i, j) || eq(i, j);
 127 }
 128
 129 /* Test for numeric equality. */
 130 static int
 131 evaluate_eqn(const pam_handle_t *pamh, const char *left, const char *right)
 132 {
 133         return evaluate_num(pamh, left, right, eq);
 134 }
 135 /* Test for string equality. */
 136 static int
 137 evaluate_eqs(const char *left, const char *right)
 138 {
 139         return (strcmp(left, right) == 0) ? PAM_SUCCESS : PAM_AUTH_ERR;
 140 }
 141 /* Test for numeric inequality. */
 142 static int
 143 evaluate_nen(const pam_handle_t *pamh, const char *left, const char *right)
 144 {
 145         return evaluate_num(pamh, left, right, ne);
 146 }
 147 /* Test for string inequality. */
 148 static int
 149 evaluate_nes(const char *left, const char *right)
 150 {
 151         return (strcmp(left, right) != 0) ? PAM_SUCCESS : PAM_AUTH_ERR;
 152 }
 153 /* Test for numeric less-than-ness(?) */
 154 static int
 155 evaluate_lt(const pam_handle_t *pamh, const char *left, const char *right)
 156 {
 157         return evaluate_num(pamh, left, right, lt);
 158 }
 159 /* Test for numeric less-than-or-equal-ness(?) */
 160 static int
 161 evaluate_le(const pam_handle_t *pamh, const char *left, const char *right)
 162 {
 163         return evaluate_num(pamh, left, right, le);
 164 }
 165 /* Test for numeric greater-than-ness(?) */
 166 static int
 167 evaluate_gt(const pam_handle_t *pamh, const char *left, const char *right)
 168 {
 169         return evaluate_num(pamh, left, right, gt);
 170 }
 171 /* Test for numeric greater-than-or-equal-ness(?) */
 172 static int
 173 evaluate_ge(const pam_handle_t *pamh, const char *left, const char *right)
 174 {
 175         return evaluate_num(pamh, left, right, ge);
 176 }
 177 /* Check for file glob match. */
 178 static int
 179 evaluate_glob(const char *left, const char *right)
 180 {
 181         return (fnmatch(right, left, 0) == 0) ? PAM_SUCCESS : PAM_AUTH_ERR;
 182 }
 183 /* Check for file glob mismatch. */
 184 static int
 185 evaluate_noglob(const char *left, const char *right)
 186 {
 187         return (fnmatch(right, left, 0) != 0) ? PAM_SUCCESS : PAM_AUTH_ERR;
 188 }
 189 /* Check for list match. */
 190 static int
 191 evaluate_inlist(const char *left, const char *right)
 192 {
 193         char *p;
 194         /* Don't care about left containing ':'. */
 195         while ((p=strstr(right, left)) != NULL) {
 196                 if (p == right || *(p-1) == ':') { /* ':' is a list separator */
 197                         p += strlen(left);
 198                         if (*p == '\0' || *p == ':') {
 199                                 return PAM_SUCCESS;
 200                         }
 201                 }
 202                 right = strchr(p, ':');
 203                 if (right == NULL)
 204                         break;
 205                 else
 206                         ++right;
 207         }
 208         return PAM_AUTH_ERR;
 209 }
 210 /* Check for list mismatch. */
 211 static int
 212 evaluate_notinlist(const char *left, const char *right)
 213 {
 214         return evaluate_inlist(left, right) != PAM_SUCCESS ? PAM_SUCCESS : PAM_AUTH_ERR;
 215 }
 216 /* Return PAM_SUCCESS if the user is in the group. */
 217 static int
 218 evaluate_ingroup(pam_handle_t *pamh, const char *user, const char *group)
 219 {
 220         if (pam_modutil_user_in_group_nam_nam(pamh, user, group) == 1)
 221                 return PAM_SUCCESS;
 222         return PAM_AUTH_ERR;
 223 }
 224 /* Return PAM_SUCCESS if the user is NOT in the group. */
 225 static int
 226 evaluate_notingroup(pam_handle_t *pamh, const char *user, const char *group)
 227 {
 228         if (pam_modutil_user_in_group_nam_nam(pamh, user, group) == 0)
 229                 return PAM_SUCCESS;
 230         return PAM_AUTH_ERR;
 231 }
 232 /* Return PAM_SUCCESS if the (host,user) is in the netgroup. */
 233 static int
 234 evaluate_innetgr(const char *host, const char *user, const char *group)
 235 {
 236         if (innetgr(group, host, user, NULL) == 1)
 237                 return PAM_SUCCESS;
 238         return PAM_AUTH_ERR;
 239 }
 240 /* Return PAM_SUCCESS if the (host,user) is NOT in the netgroup. */
 241 static int
 242 evaluate_notinnetgr(const char *host, const char *user, const char *group)
 243 {
 244         if (innetgr(group, host, user, NULL) == 0)
 245                 return PAM_SUCCESS;
 246         return PAM_AUTH_ERR;
 247 }
 248
 249 /* Match a triple. */
 250 static int
 251 evaluate(pam_handle_t *pamh, int debug,
 252          const char *left, const char *qual, const char *right,
 253          struct passwd *pwd, const char *user)
 254 {
 255         char buf[LINE_MAX] = "";
 256         const char *attribute = left;
 257         /* Figure out what we're evaluating here, and convert it to a string.*/
 258         if ((strcasecmp(left, "login") == 0) ||
 259             (strcasecmp(left, "name") == 0) ||
 260             (strcasecmp(left, "user") == 0)) {
 261                 snprintf(buf, sizeof(buf), "%s", user);
 262                 left = buf;
 263         }
 264         if (strcasecmp(left, "uid") == 0) {
 265                 snprintf(buf, sizeof(buf), "%lu", (unsigned long) pwd->pw_uid);
 266                 left = buf;
 267         }
 268         if (strcasecmp(left, "gid") == 0) {
 269                 snprintf(buf, sizeof(buf), "%lu", (unsigned long) pwd->pw_gid);
 270                 left = buf;
 271         }
 272         if (strcasecmp(left, "shell") == 0) {
 273                 snprintf(buf, sizeof(buf), "%s", pwd->pw_shell);
 274                 left = buf;
 275         }
 276         if ((strcasecmp(left, "home") == 0) ||
 277             (strcasecmp(left, "dir") == 0) ||
 278             (strcasecmp(left, "homedir") == 0)) {
 279                 snprintf(buf, sizeof(buf), "%s", pwd->pw_dir);
 280                 left = buf;
 281         }
 282         if (strcasecmp(left, "service") == 0) {
 283                 const void *svc;
 284                 if (pam_get_item(pamh, PAM_SERVICE, &svc) != PAM_SUCCESS)
 285                         svc = "";
 286                 snprintf(buf, sizeof(buf), "%s", (const char *)svc);
 287                 left = buf;
 288         }
 289         /* If we have no idea what's going on, return an error. */
 290         if (left != buf) {
 291                 pam_syslog(pamh, LOG_CRIT, "unknown attribute \"%s\"", left);
 292                 return PAM_SERVICE_ERR;
 293         }
 294         if (debug) {
 295                 pam_syslog(pamh, LOG_DEBUG, "'%s' resolves to '%s'",
 296                            attribute, left);
 297         }
 298
 299         /* Attribute value < some threshold. */
 300         if ((strcasecmp(qual, "<") == 0) ||
 301             (strcasecmp(qual, "lt") == 0)) {
 302                 return evaluate_lt(pamh, left, right);
 303         }
 304         /* Attribute value <= some threshold. */
 305         if ((strcasecmp(qual, "<=") == 0) ||
 306             (strcasecmp(qual, "le") == 0)) {
 307                 return evaluate_le(pamh, left, right);
 308         }
 309         /* Attribute value > some threshold. */
 310         if ((strcasecmp(qual, ">") == 0) ||
 311             (strcasecmp(qual, "gt") == 0)) {
 312                 return evaluate_gt(pamh, left, right);
 313         }
 314         /* Attribute value >= some threshold. */
 315         if ((strcasecmp(qual, ">=") == 0) ||
 316             (strcasecmp(qual, "ge") == 0)) {
 317                 return evaluate_ge(pamh, left, right);
 318         }
 319         /* Attribute value == some threshold. */
 320         if (strcasecmp(qual, "eq") == 0) {
 321                 return evaluate_eqn(pamh, left, right);
 322         }
 323         /* Attribute value = some string. */
 324         if (strcasecmp(qual, "=") == 0) {
 325                 return evaluate_eqs(left, right);
 326         }
 327         /* Attribute value != some threshold. */
 328         if (strcasecmp(qual, "ne") == 0) {
 329                 return evaluate_nen(pamh, left, right);
 330         }
 331         /* Attribute value != some string. */
 332         if (strcasecmp(qual, "!=") == 0) {
 333                 return evaluate_nes(left, right);
 334         }
 335         /* Attribute value matches some pattern. */
 336         if ((strcasecmp(qual, "=~") == 0) ||
 337             (strcasecmp(qual, "glob") == 0)) {
 338                 return evaluate_glob(left, right);
 339         }
 340         if ((strcasecmp(qual, "!~") == 0) ||
 341             (strcasecmp(qual, "noglob") == 0)) {
 342                 return evaluate_noglob(left, right);
 343         }
 344         /* Attribute value matches item in list. */
 345         if (strcasecmp(qual, "in") == 0) {
 346                 return evaluate_inlist(left, right);
 347         }
 348         if (strcasecmp(qual, "notin") == 0) {
 349                 return evaluate_notinlist(left, right);
 350         }
 351         /* User is in this group. */
 352         if (strcasecmp(qual, "ingroup") == 0) {
 353                 return evaluate_ingroup(pamh, user, right);
 354         }
 355         /* User is not in this group. */
 356         if (strcasecmp(qual, "notingroup") == 0) {
 357                 return evaluate_notingroup(pamh, user, right);
 358         }
 359         /* (Rhost, user) is in this netgroup. */
 360         if (strcasecmp(qual, "innetgr") == 0) {
 361                 const void *rhost;
 362                 if (pam_get_item(pamh, PAM_RHOST, &rhost) != PAM_SUCCESS)
 363                         rhost = NULL;
 364                 return evaluate_innetgr(rhost, user, right);
 365         }
 366         /* (Rhost, user) is not in this group. */
 367         if (strcasecmp(qual, "notinnetgr") == 0) {
 368                 const void *rhost;
 369                 if (pam_get_item(pamh, PAM_RHOST, &rhost) != PAM_SUCCESS)
 370                         rhost = NULL;
 371                 return evaluate_notinnetgr(rhost, user, right);
 372         }
 373         /* Fail closed. */
 374         return PAM_SERVICE_ERR;
 375 }
 376
 377 PAM_EXTERN int
 378 pam_sm_authenticate (pam_handle_t *pamh, int flags UNUSED,
 379                      int argc, const char **argv)
 380 {
 381         const void *prompt;
 382         const char *user;
 383         struct passwd *pwd;
 384         int ret, i, count, use_uid, debug;
 385         const char *left, *right, *qual;
 386         int quiet_fail, quiet_succ, audit;
 387
 388         /* Get the user prompt. */
 389         ret = pam_get_item(pamh, PAM_USER_PROMPT, &prompt);
 390         if ((ret != PAM_SUCCESS) || (prompt == NULL) || (strlen(prompt) == 0)) {
 391                 prompt = "login: ";
 392         }
 393
 394         quiet_fail = 0;
 395         quiet_succ = 0;
 396         audit = 0;
 397         for (use_uid = 0, debug = 0, i = 0; i < argc; i++) {
 398                 if (strcmp(argv[i], "debug") == 0) {
 399                         debug++;
 400                 }
 401                 if (strcmp(argv[i], "use_uid") == 0) {
 402                         use_uid++;
 403                 }
 404                 if (strcmp(argv[i], "quiet") == 0) {
 405                         quiet_fail++;
 406                         quiet_succ++;
 407                 }
 408                 if (strcmp(argv[i], "quiet_fail") == 0) {
 409                         quiet_fail++;
 410                 }
 411                 if (strcmp(argv[i], "quiet_success") == 0) {
 412                         quiet_succ++;
 413                 }
 414                 if (strcmp(argv[i], "audit") == 0) {
 415                         audit++;
 416                 }
 417         }
 418
 419         if (use_uid) {
 420                 /* Get information about the user. */
 421                 pwd = pam_modutil_getpwuid(pamh, getuid());
 422                 if (pwd == NULL) {
 423                         pam_syslog(pamh, LOG_CRIT,
 424                                    "error retrieving information about user %lu",
 425                                    (unsigned long)getuid());
 426                         return PAM_USER_UNKNOWN;
 427                 }
 428                 user = pwd->pw_name;
 429         } else {
 430                 /* Get the user's name. */
 431                 ret = pam_get_user(pamh, &user, prompt);
 432                 if ((ret != PAM_SUCCESS) || (user == NULL)) {
 433                         pam_syslog(pamh, LOG_CRIT,
 434                                    "error retrieving user name: %s",
 435                                    pam_strerror(pamh, ret));
 436                         return ret;
 437                 }
 438
 439                 /* Get information about the user. */
 440                 pwd = pam_modutil_getpwnam(pamh, user);
 441                 if (pwd == NULL) {
 442                         if(audit)
 443                                 pam_syslog(pamh, LOG_NOTICE,
 444                                            "error retrieving information about user %s",
 445                                            user);
 446                         return PAM_USER_UNKNOWN;
 447                 }
 448         }
 449
 450         /* Walk the argument list. */
 451         count = 0;
 452         left = qual = right = NULL;
 453         for (i = 0; i < argc; i++) {
 454                 if (strcmp(argv[i], "debug") == 0) {
 455                         continue;
 456                 }
 457                 if (strcmp(argv[i], "use_uid") == 0) {
 458                         continue;
 459                 }
 460                 if (strcmp(argv[i], "quiet") == 0) {
 461                         continue;
 462                 }
 463                 if (strcmp(argv[i], "quiet_fail") == 0) {
 464                         continue;
 465                 }
 466                 if (strcmp(argv[i], "quiet_success") == 0) {
 467                         continue;
 468                 }
 469                 if (strcmp(argv[i], "audit") == 0) {
 470                         continue;
 471                 }
 472                 if (left == NULL) {
 473                         left = argv[i];
 474                         continue;
 475                 }
 476                 if (qual == NULL) {
 477                         qual = argv[i];
 478                         continue;
 479                 }
 480                 if (right == NULL) {
 481                         right = argv[i];
 482                         if (right == NULL)
 483                                 continue;
 484
 485                         count++;
 486                         ret = evaluate(pamh, debug,
 487                                        left, qual, right,
 488                                        pwd, user);
 489                         if (ret != PAM_SUCCESS) {
 490                                 if(!quiet_fail)
 491                                         pam_syslog(pamh, LOG_INFO,
 492                                                    "requirement \"%s %s %s\" "
 493                                                    "not met by user \"%s\"",
 494                                                    left, qual, right, user);
 495                                 left = qual = right = NULL;
 496                                 break;
 497                         }
 498                         else
 499                                 if(!quiet_succ)
 500                                         pam_syslog(pamh, LOG_INFO,
 501                                                    "requirement \"%s %s %s\" "
 502                                                    "was met by user \"%s\"",
 503                                                    left, qual, right, user);
 504                         left = qual = right = NULL;
 505                         continue;
 506                 }
 507         }
 508
 509         if (left || qual || right) {
 510                 ret = PAM_SERVICE_ERR;
 511                 pam_syslog(pamh, LOG_CRIT,
 512                         "incomplete condition detected");
 513         } else if (count == 0) {
 514                 pam_syslog(pamh, LOG_INFO,
 515                         "no condition detected; module succeeded");
 516         }
 517
 518         return ret;
 519 }
 520
 521 PAM_EXTERN int
 522 pam_sm_setcred(pam_handle_t *pamh UNUSED, int flags UNUSED,
 523                int argc UNUSED, const char **argv UNUSED)
 524 {
 525         return PAM_IGNORE;
 526 }
 527
 528 PAM_EXTERN int
 529 pam_sm_acct_mgmt(pam_handle_t *pamh, int flags, int argc, const char **argv)
 530 {
 531         return pam_sm_authenticate(pamh, flags, argc, argv);
 532 }
 533
 534 PAM_EXTERN int
 535 pam_sm_open_session(pam_handle_t *pamh, int flags, int argc, const char **argv)
 536 {
 537         return pam_sm_authenticate(pamh, flags, argc, argv);
 538 }
 539
 540 PAM_EXTERN int
 541 pam_sm_close_session(pam_handle_t *pamh, int flags, int argc, const char **argv)
 542 {
 543         return pam_sm_authenticate(pamh, flags, argc, argv);
 544 }
 545
 546 PAM_EXTERN int
 547 pam_sm_chauthtok(pam_handle_t *pamh, int flags, int argc, const char **argv)
 548 {
 549         return pam_sm_authenticate(pamh, flags, argc, argv);
 550 }
 551
 552 /* static module data */
 553 #ifdef PAM_STATIC
 554 struct pam_module _pam_succeed_if_modstruct = {
 555     "pam_succeed_if",
 556     pam_sm_authenticate,
 557     pam_sm_setcred,
 558     pam_sm_acct_mgmt,
 559     pam_sm_open_session,
 560     pam_sm_close_session,
 561     pam_sm_chauthtok
 562 };
 563 #endif