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 #include "pppd.h"
  77 #include "session.h"
  78
  79 #ifdef USE_PAM
  80 #include <security/pam_appl.h>
  81 #endif /* #ifdef USE_PAM */
  82
  83 #define SET_MSG(var, msg) if (var != NULL) { var[0] = msg; }
  84 #define COPY_STRING(s) ((s) ? strdup(s) : NULL)
  85
  86 #define SUCCESS_MSG "Session started successfully"
  87 #define ABORT_MSG "Session can't be started without a username"
  88 #define SERVICE_NAME "ppp"
  89
  90 #define SESSION_FAILED  0
  91 #define SESSION_OK      1
  92
  93 /* We have successfully started a session */
  94 static bool logged_in = 0;
  95
  96 #ifdef USE_PAM
  97 /*
  98  * Static variables used to communicate between the conversation function
  99  * and the server_login function
 100  */
 101 static const char *PAM_username;
 102 static const char *PAM_password;
 103 static int   PAM_session = 0;
 104 static pam_handle_t *pamh = NULL;
 105
 106 /* PAM conversation function
 107  * Here we assume (for now, at least) that echo on means login name, and
 108  * echo off means password.
 109  */
 110
 111 static int conversation (int num_msg,
 112 #ifndef SOL2
 113     const
 114 #endif
 115     struct pam_message **msg,
 116     struct pam_response **resp, void *appdata_ptr)
 117 {
 118     int replies = 0;
 119     struct pam_response *reply = NULL;
 120
 121     reply = malloc(sizeof(struct pam_response) * num_msg);
 122     if (!reply) return PAM_CONV_ERR;
 123
 124     for (replies = 0; replies < num_msg; replies++) {
 125         switch (msg[replies]->msg_style) {
 126             case PAM_PROMPT_ECHO_ON:
 127                 reply[replies].resp_retcode = PAM_SUCCESS;
 128                 reply[replies].resp = COPY_STRING(PAM_username);
 129                 /* PAM frees resp */
 130                 break;
 131             case PAM_PROMPT_ECHO_OFF:
 132                 reply[replies].resp_retcode = PAM_SUCCESS;
 133                 reply[replies].resp = COPY_STRING(PAM_password);
 134                 /* PAM frees resp */
 135                 break;
 136             case PAM_TEXT_INFO:
 137                 /* fall through */
 138             case PAM_ERROR_MSG:
 139                 /* ignore it, but pam still wants a NULL response... */
 140                 reply[replies].resp_retcode = PAM_SUCCESS;
 141                 reply[replies].resp = NULL;
 142                 break;
 143             default:
 144                 /* Must be an error of some sort... */
 145                 free (reply);
 146                 return PAM_CONV_ERR;
 147         }
 148     }
 149     *resp = reply;
 150     return PAM_SUCCESS;
 151 }
 152
 153 static struct pam_conv pam_conv_data = {
 154     &conversation,
 155     NULL
 156 };
 157 #endif /* #ifdef USE_PAM */
 158
 159 int
 160 session_start(flags, user, passwd, ttyName, msg)
 161     const int flags;
 162     const char *user;
 163     const char *passwd;
 164     const char *ttyName;
 165     char **msg;
 166 {
 167     bool ok = 1;
 168 #ifdef USE_PAM
 169     const char *usr;
 170     int pam_error;
 171     bool try_session = 0;
 172 #else /* #ifdef USE_PAM */
 173     struct passwd *pw;
 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
 293  */
 294
 295     if ((SESS_AUTH & flags)) {
 296         pw = getpwnam(user);
 297
 298         endpwent();
 299         /*
 300          * Here, we bail if we have no user account, because there is nothing
 301          * to verify against.
 302          */
 303         if (pw == NULL)
 304             return SESSION_FAILED;
 305
 306 #ifdef HAS_SHADOW
 307
 308         spwd = getspnam(user);
 309         endspent();
 310
 311         /*
 312          * If there is no shadow entry for the user, then we can't verify the
 313          * account.
 314          */
 315         if (spwd == NULL)
 316             return SESSION_FAILED;
 317
 318         /*
 319          * We check validity all the time, because if the password has expired,
 320          * then clearly we should not authenticate against it (if we're being
 321          * called for authentication only).  Thus, in this particular instance,
 322          * there is no real difference between using the AUTH, SESS or ACCT
 323          * flags, or combinations thereof.
 324          */
 325         now = time(NULL) / 86400L;
 326         if ((spwd->sp_expire > 0 && now >= spwd->sp_expire)
 327             || ((spwd->sp_max >= 0 && spwd->sp_max < 10000)
 328             && spwd->sp_lstchg >= 0
 329             && now >= spwd->sp_lstchg + spwd->sp_max)) {
 330             warn("Password for %s has expired", user);
 331             return SESSION_FAILED;
 332         }
 333
 334         /* We have a valid shadow entry, keep the password */
 335         pw->pw_passwd = spwd->sp_pwdp;
 336
 337 #endif /* #ifdef HAS_SHADOW */
 338
 339         /*
 340          * If no passwd, don't let them login if we're authenticating.
 341          */
 342         if (pw->pw_passwd == NULL || strlen(pw->pw_passwd) < 2
 343             || strcmp(crypt(passwd, pw->pw_passwd), pw->pw_passwd) != 0)
 344             return SESSION_FAILED;
 345     }
 346
 347 #endif /* #ifdef USE_PAM */
 348
 349     /*
 350      * Write a wtmp entry for this user.
 351      */
 352
 353     if (SESS_ACCT & flags) {
 354         if (strncmp(ttyName, "/dev/", 5) == 0)
 355             ttyName += 5;
 356         logwtmp(ttyName, user, ifname); /* Add wtmp login entry */
 357         logged_in = 1;
 358
 359 #if defined(_PATH_LASTLOG) && !defined(USE_PAM)
 360         {
 361             struct lastlog ll;
 362             int fd;
 363
 364             if ((fd = open(_PATH_LASTLOG, O_RDWR, 0)) >= 0) {
 365                 (void)lseek(fd, (off_t)(pw->pw_uid * sizeof(ll)), SEEK_SET);
 366                 memset((void *)&ll, 0, sizeof(ll));
 367                 (void)time(&ll.ll_time);
 368                 (void)strncpy(ll.ll_line, ttyName, sizeof(ll.ll_line));
 369                 (void)strncpy(ll.ll_host, ifname, sizeof(ll.ll_host));
 370                 (void)write(fd, (char *)&ll, sizeof(ll));
 371                 (void)close(fd);
 372             }
 373         }
 374 #endif /* _PATH_LASTLOG and not USE_PAM */
 375         info("user %s logged in on tty %s intf %s", user, ttyName, ifname);
 376     }
 377
 378     return SESSION_OK;
 379 }
 380
 381 /*
 382  * session_end - Logout the user.
 383  */
 384 void
 385 session_end(const char* ttyName)
 386 {
 387 #ifdef USE_PAM
 388     int pam_error = PAM_SUCCESS;
 389
 390     if (pamh != NULL) {
 391         if (PAM_session) pam_error = pam_close_session (pamh, PAM_SILENT);
 392         PAM_session = 0;
 393         pam_end (pamh, pam_error);
 394         pamh = NULL;
 395         /* Apparently the pam stuff does closelog(). */
 396         reopen_log();
 397     }
 398 #endif
 399     if (logged_in) {
 400         if (strncmp(ttyName, "/dev/", 5) == 0)
 401             ttyName += 5;
 402         logwtmp(ttyName, "", ""); /* Wipe out utmp logout entry */
 403         logged_in = 0;
 404     }
 405 }