pppd/session.c

   1 /*
   2  * session.c - PPP session control.
   3  *
   4  * Copyright (c) 2007 Diego Rivera. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. The name(s) of the authors of this software must not be used to
  14  *    endorse or promote products derived from this software without
  15  *    prior written permission.
  16  *
  17  * 3. Redistributions of any form whatsoever must retain the following
  18  *    acknowledgment:
  19  *    "This product includes software developed by Paul Mackerras
  20  *     <paulus@samba.org>".
  21  *
  22  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  23  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  24  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  25  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  26  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  27  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  28  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  29  *
  30  * Derived from auth.c, which is:
  31  *
  32  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
  33  *
  34  * Redistribution and use in source and binary forms, with or without
  35  * modification, are permitted provided that the following conditions
  36  * are met:
  37  *
  38  * 1. Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  *
  41  * 2. Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in
  43  *    the documentation and/or other materials provided with the
  44  *    distribution.
  45  *
  46  * 3. The name "Carnegie Mellon University" must not be used to
  47  *    endorse or promote products derived from this software without
  48  *    prior written permission. For permission or any legal
  49  *    details, please contact
  50  *      Office of Technology Transfer
  51  *      Carnegie Mellon University
  52  *      5000 Forbes Avenue
  53  *      Pittsburgh, PA  15213-3890
  54  *      (412) 268-4387, fax: (412) 268-7395
  55  *      tech-transfer@andrew.cmu.edu
  56  *
  57  * 4. Redistributions of any form whatsoever must retain the following
  58  *    acknowledgment:
  59  *    "This product includes software developed by Computing Services
  60  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
  61  *
  62  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
  63  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  64  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
  65  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  66  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  67  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  68  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  69  */
  70
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74 #include <pwd.h>
  75 #include <crypt.h>
  76 #ifdef HAS_SHADOW
  77 #include <shadow.h>
  78 #endif
  79 #include <time.h>
  80 #include <utmp.h>
  81 #include <fcntl.h>
  82 #include <unistd.h>
  83 #include "pppd.h"
  84 #include "session.h"
  85
  86 #ifdef USE_PAM
  87 #include <security/pam_appl.h>
  88 #endif /* #ifdef USE_PAM */
  89
  90 #define SET_MSG(var, msg) if (var != NULL) { var[0] = msg; }
  91 #define COPY_STRING(s) ((s) ? strdup(s) : NULL)
  92
  93 #define SUCCESS_MSG "Session started successfully"
  94 #define ABORT_MSG "Session can't be started without a username"
  95 #define SERVICE_NAME "ppp"
  96
  97 #define SESSION_FAILED  0
  98 #define SESSION_OK      1
  99
 100 /* We have successfully started a session */
 101 static bool logged_in = 0;
 102
 103 #ifdef USE_PAM
 104 /*
 105  * Static variables used to communicate between the conversation function
 106  * and the server_login function
 107  */
 108 static const char *PAM_username;
 109 static const char *PAM_password;
 110 static int   PAM_session = 0;
 111 static pam_handle_t *pamh = NULL;
 112
 113 /* PAM conversation function
 114  * Here we assume (for now, at least) that echo on means login name, and
 115  * echo off means password.
 116  */
 117
 118 static int conversation (int num_msg,
 119     const struct pam_message **msg,
 120     struct pam_response **resp, void *appdata_ptr)
 121 {
 122     int replies = 0;
 123     struct pam_response *reply = NULL;
 124
 125     reply = malloc(sizeof(struct pam_response) * num_msg);
 126     if (!reply) return PAM_CONV_ERR;
 127
 128     for (replies = 0; replies < num_msg; replies++) {
 129         switch (msg[replies]->msg_style) {
 130             case PAM_PROMPT_ECHO_ON:
 131                 reply[replies].resp_retcode = PAM_SUCCESS;
 132                 reply[replies].resp = COPY_STRING(PAM_username);
 133                 /* PAM frees resp */
 134                 break;
 135             case PAM_PROMPT_ECHO_OFF:
 136                 reply[replies].resp_retcode = PAM_SUCCESS;
 137                 reply[replies].resp = COPY_STRING(PAM_password);
 138                 /* PAM frees resp */
 139                 break;
 140             case PAM_TEXT_INFO:
 141                 /* fall through */
 142             case PAM_ERROR_MSG:
 143                 /* ignore it, but pam still wants a NULL response... */
 144                 reply[replies].resp_retcode = PAM_SUCCESS;
 145                 reply[replies].resp = NULL;
 146                 break;
 147             default:
 148                 /* Must be an error of some sort... */
 149                 free (reply);
 150                 return PAM_CONV_ERR;
 151         }
 152     }
 153     *resp = reply;
 154     return PAM_SUCCESS;
 155 }
 156
 157 static struct pam_conv pam_conv_data = {
 158     &conversation,
 159     NULL
 160 };
 161 #endif /* #ifdef USE_PAM */
 162
 163 int
 164 session_start(const int flags, const char *user, const char *passwd, const char *ttyName, char **msg)
 165 {
 166 #ifdef USE_PAM
 167     bool ok = 1;
 168     const char *usr;
 169     int pam_error;
 170     bool try_session = 0;
 171 #else /* #ifdef USE_PAM */
 172     struct passwd *pw;
 173     char *cbuf;
 174 #ifdef HAS_SHADOW
 175     struct spwd *spwd;
 176     struct spwd *getspnam();
 177     long now = 0;
 178 #endif /* #ifdef HAS_SHADOW */
 179 #endif /* #ifdef USE_PAM */
 180
 181     SET_MSG(msg, SUCCESS_MSG);
 182
 183     /* If no verification is requested, then simply return an OK */
 184     if (!(SESS_ALL & flags)) {
 185         return SESSION_OK;
 186     }
 187
 188     if (user == NULL) {
 189        SET_MSG(msg, ABORT_MSG);
 190        return SESSION_FAILED;
 191     }
 192
 193 #ifdef USE_PAM
 194     /* Find the '\\' in the username */
 195     /* This needs to be fixed to support different username schemes */
 196     if ((usr = strchr(user, '\\')) == NULL)
 197         usr = user;
 198     else
 199         usr++;
 200
 201     PAM_session = 0;
 202     PAM_username = usr;
 203     PAM_password = passwd;
 204
 205     dbglog("Initializing PAM (%d) for user %s", flags, usr);
 206     pam_error = pam_start (SERVICE_NAME, usr, &pam_conv_data, &pamh);
 207     dbglog("---> PAM INIT Result = %d", pam_error);
 208     ok = (pam_error == PAM_SUCCESS);
 209
 210     if (ok) {
 211         ok = (pam_set_item(pamh, PAM_TTY, ttyName) == PAM_SUCCESS) &&
 212             (pam_set_item(pamh, PAM_RHOST, ifname) == PAM_SUCCESS);
 213     }
 214
 215     if (ok && (SESS_AUTH & flags)) {
 216         dbglog("Attempting PAM authentication");
 217         pam_error = pam_authenticate (pamh, PAM_SILENT);
 218         if (pam_error == PAM_SUCCESS) {
 219             /* PAM auth was OK */
 220             dbglog("PAM Authentication OK for %s", user);
 221         } else {
 222             /* No matter the reason, we fail because we're authenticating */
 223             ok = 0;
 224             if (pam_error == PAM_USER_UNKNOWN) {
 225                 dbglog("User unknown, failing PAM authentication");
 226                 SET_MSG(msg, "User unknown - cannot authenticate via PAM");
 227             } else {
 228                 /* Any other error means authentication was bad */
 229                 dbglog("PAM Authentication failed: %d: %s", pam_error,
 230                        pam_strerror(pamh, pam_error));
 231                 SET_MSG(msg, (char *) pam_strerror (pamh, pam_error));
 232             }
 233         }
 234     }
 235
 236     if (ok && (SESS_ACCT & flags)) {
 237         dbglog("Attempting PAM account checks");
 238         pam_error = pam_acct_mgmt (pamh, PAM_SILENT);
 239         if (pam_error == PAM_SUCCESS) {
 240             /*
 241              * PAM account was OK, set the flag which indicates that we should
 242              * try to perform the session checks.
 243              */
 244             try_session = 1;
 245             dbglog("PAM Account OK for %s", user);
 246         } else {
 247             /*
 248              * If the account checks fail, then we should not try to perform
 249              * the session check, because they don't make sense.
 250              */
 251             try_session = 0;
 252             if (pam_error == PAM_USER_UNKNOWN) {
 253                 /*
 254                  * We're checking the account, so it's ok to not have one
 255                  * because the user might come from the secrets files, or some
 256                  * other plugin.
 257                  */
 258                 dbglog("User unknown, ignoring PAM restrictions");
 259                 SET_MSG(msg, "User unknown - ignoring PAM restrictions");
 260             } else {
 261                 /* Any other error means session is rejected */
 262                 ok = 0;
 263                 dbglog("PAM Account checks failed: %d: %s", pam_error,
 264                        pam_strerror(pamh, pam_error));
 265                 SET_MSG(msg, (char *) pam_strerror (pamh, pam_error));
 266             }
 267         }
 268     }
 269
 270     if (ok && try_session && (SESS_ACCT & flags)) {
 271         /* Only open a session if the user's account was found */
 272         pam_error = pam_open_session (pamh, PAM_SILENT);
 273         if (pam_error == PAM_SUCCESS) {
 274             dbglog("PAM Session opened for user %s", user);
 275             PAM_session = 1;
 276         } else {
 277             dbglog("PAM Session denied for user %s", user);
 278             SET_MSG(msg, (char *) pam_strerror (pamh, pam_error));
 279             ok = 0;
 280         }
 281     }
 282
 283     /* This is needed because apparently the PAM stuff closes the log */
 284     reopen_log();
 285
 286     /* If our PAM checks have already failed, then we must return a failure */
 287     if (!ok) return SESSION_FAILED;
 288
 289 #else /* #ifdef USE_PAM */
 290
 291 /*
 292  * Use the non-PAM methods directly.  'pw' will remain NULL if the user
 293  * has not been authenticated using local UNIX system services.
 294  */
 295
 296     pw = NULL;
 297     if ((SESS_AUTH & flags)) {
 298         pw = getpwnam(user);
 299
 300         endpwent();
 301         /*
 302          * Here, we bail if we have no user account, because there is nothing
 303          * to verify against.
 304          */
 305         if (pw == NULL)
 306             return SESSION_FAILED;
 307
 308 #ifdef HAS_SHADOW
 309
 310         spwd = getspnam(user);
 311         endspent();
 312
 313         /*
 314          * If there is no shadow entry for the user, then we can't verify the
 315          * account.
 316          */
 317         if (spwd == NULL)
 318             return SESSION_FAILED;
 319
 320         /*
 321          * We check validity all the time, because if the password has expired,
 322          * then clearly we should not authenticate against it (if we're being
 323          * called for authentication only).  Thus, in this particular instance,
 324          * there is no real difference between using the AUTH, SESS or ACCT
 325          * flags, or combinations thereof.
 326          */
 327         now = time(NULL) / 86400L;
 328         if ((spwd->sp_expire > 0 && now >= spwd->sp_expire)
 329             || ((spwd->sp_max >= 0 && spwd->sp_max < 10000)
 330             && spwd->sp_lstchg >= 0
 331             && now >= spwd->sp_lstchg + spwd->sp_max)) {
 332             warn("Password for %s has expired", user);
 333             return SESSION_FAILED;
 334         }
 335
 336         /* We have a valid shadow entry, keep the password */
 337         pw->pw_passwd = spwd->sp_pwdp;
 338
 339 #endif /* #ifdef HAS_SHADOW */
 340
 341         /*
 342          * If no passwd, don't let them login if we're authenticating.
 343          */
 344         if (pw->pw_passwd == NULL || strlen(pw->pw_passwd) < 2)
 345             return SESSION_FAILED;
 346         cbuf = crypt(passwd, pw->pw_passwd);
 347         if (!cbuf || strcmp(cbuf, pw->pw_passwd) != 0)
 348             return SESSION_FAILED;
 349     }
 350
 351 #endif /* #ifdef USE_PAM */
 352
 353     /*
 354      * Write a wtmp entry for this user.
 355      */
 356
 357     if (SESS_ACCT & flags) {
 358         if (strncmp(ttyName, "/dev/", 5) == 0)
 359             ttyName += 5;
 360         logwtmp(ttyName, user, ifname); /* Add wtmp login entry */
 361         logged_in = 1;
 362
 363 #if defined(_PATH_LASTLOG) && !defined(USE_PAM)
 364         /*
 365          * Enter the user in lastlog only if he has been authenticated using
 366          * local system services.  If he has not, then we don't know what his
 367          * UID might be, and lastlog is indexed by UID.
 368          */
 369         if (pw != NULL) {
 370             struct lastlog ll;
 371             int fd;
 372             time_t tnow;
 373
 374             if ((fd = open(_PATH_LASTLOG, O_RDWR, 0)) >= 0) {
 375                 (void)lseek(fd, (off_t)(pw->pw_uid * sizeof(ll)), SEEK_SET);
 376                 memset((void *)&ll, 0, sizeof(ll));
 377                 (void)time(&tnow);
 378                 ll.ll_time = tnow;
 379                 strlcpy(ll.ll_line, ttyName, sizeof(ll.ll_line));
 380                 strlcpy(ll.ll_host, ifname, sizeof(ll.ll_host));
 381                 (void)write(fd, (char *)&ll, sizeof(ll));
 382                 (void)close(fd);
 383             }
 384         }
 385 #endif /* _PATH_LASTLOG and not USE_PAM */
 386         info("user %s logged in on tty %s intf %s", user, ttyName, ifname);
 387     }
 388
 389     return SESSION_OK;
 390 }
 391
 392 /*
 393  * session_end - Logout the user.
 394  */
 395 void
 396 session_end(const char* ttyName)
 397 {
 398 #ifdef USE_PAM
 399     int pam_error = PAM_SUCCESS;
 400
 401     if (pamh != NULL) {
 402         if (PAM_session) pam_error = pam_close_session (pamh, PAM_SILENT);
 403         PAM_session = 0;
 404         pam_end (pamh, pam_error);
 405         pamh = NULL;
 406         /* Apparently the pam stuff does closelog(). */
 407         reopen_log();
 408     }
 409 #endif
 410     if (logged_in) {
 411         if (strncmp(ttyName, "/dev/", 5) == 0)
 412             ttyName += 5;
 413         logwtmp(ttyName, "", ""); /* Wipe out utmp logout entry */
 414         logged_in = 0;
 415     }
 416 }