source3/pam_smbpass/pam_smb_passwd.c

   1 /* Unix NT password database implementation, version 0.7.5.
   2  *
   3  * This program is free software; you can redistribute it and/or modify it under
   4  * the terms of the GNU General Public License as published by the Free
   5  * Software Foundation; either version 2 of the License, or (at your option)
   6  * any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 675
  15  * Mass Ave, Cambridge, MA 02139, USA.
  16 */
  17
  18 /* indicate the following groups are defined */
  19 #define PAM_SM_PASSWORD
  20
  21 #include "includes.h"
  22
  23 #ifndef LINUX
  24
  25 /* This is only used in the Sun implementation. */
  26 #include <security/pam_appl.h>
  27
  28 #endif  /* LINUX */
  29
  30 #include <security/pam_modules.h>
  31
  32 #include "general.h"
  33
  34 #include "support.h"
  35
  36 int smb_update_db( pam_handle_t *pamh, int ctrl, const char *user
  37                    , const char *pass_new )
  38 {
  39  char           c;
  40  int            retval, i;
  41  pstring        err_str;
  42  pstring        msg_str;
  43
  44     err_str[0] = '\0';
  45     msg_str[0] = '\0';
  46
  47     retval = local_password_change( user, LOCAL_SET_PASSWORD, pass_new, err_str, sizeof(err_str),
  48                                     msg_str, sizeof(msg_str) );
  49
  50     if (!retval) {
  51         if (*err_str) {
  52             err_str[PSTRING_LEN-1] = '\0';
  53             make_remark( pamh, ctrl, PAM_ERROR_MSG, err_str );
  54         }
  55
  56         /* FIXME: what value is appropriate here? */
  57         retval = PAM_AUTHTOK_ERR;
  58     } else {
  59         if (*msg_str) {
  60             msg_str[PSTRING_LEN-1] = '\0';
  61             make_remark( pamh, ctrl, PAM_TEXT_INFO, msg_str );
  62         }
  63         retval = PAM_SUCCESS;
  64     }
  65
  66     return retval;
  67
  68 }
  69
  70
  71 /* data tokens */
  72
  73 #define _SMB_OLD_AUTHTOK  "-SMB-OLD-PASS"
  74 #define _SMB_NEW_AUTHTOK  "-SMB-NEW-PASS"
  75
  76 /*
  77  * FUNCTION: pam_sm_chauthtok()
  78  *
  79  * This function is called twice by the PAM library, once with
  80  * PAM_PRELIM_CHECK set, and then again with PAM_UPDATE_AUTHTOK set.  With
  81  * Linux-PAM, these two passes generally involve first checking the old
  82  * token and then changing the token.  This is what we do here.
  83  *
  84  * Having obtained a new password. The function updates the
  85  * SMB_PASSWD_FILE file (normally, $(LIBDIR)/smbpasswd).
  86  */
  87
  88 int pam_sm_chauthtok(pam_handle_t *pamh, int flags,
  89                      int argc, const char **argv)
  90 {
  91     unsigned int ctrl;
  92     int retval;
  93
  94     extern BOOL in_client;
  95
  96     struct smb_passwd *smb_pwent=NULL;
  97     const char *user;
  98     const char *pass_old, *pass_new;
  99
 100     /* Samba initialization. */
 101     setup_logging( "pam_smbpass", False );
 102     in_client = True;
 103
 104     ctrl = set_ctrl(flags, argc, argv);
 105
 106     /*
 107      * First get the name of a user.  No need to do anything if we can't
 108      * determine this.
 109      */
 110
 111     retval = pam_get_user( pamh, &user, "Username: " );
 112     if (retval != PAM_SUCCESS) {
 113         if (on( SMB_DEBUG, ctrl )) {
 114             _log_err( LOG_DEBUG, "password: could not identify user" );
 115         }
 116         return retval;
 117     }
 118     if (on( SMB_DEBUG, ctrl )) {
 119         _log_err( LOG_DEBUG, "username [%s] obtained", user );
 120     }
 121
 122     if (!initialize_password_db(True)) {
 123         _log_err( LOG_ALERT, "Cannot access samba password database" );
 124         return PAM_AUTHINFO_UNAVAIL;
 125     }
 126
 127     /* obtain user record */
 128     smb_pwent = getsmbpwnam(user);
 129
 130     if (smb_pwent == NULL) {
 131         _log_err( LOG_ALERT, "Failed to find entry for user %s.", user );
 132         return PAM_USER_UNKNOWN;
 133     }
 134
 135     if (flags & PAM_PRELIM_CHECK) {
 136         /*
 137          * obtain and verify the current password (OLDAUTHTOK) for
 138          * the user.
 139          */
 140
 141         char *Announce;
 142
 143         if (_smb_blankpasswd( ctrl, smb_pwent )) {
 144
 145             return PAM_SUCCESS;
 146
 147         }
 148
 149         /* Password change by root, or for an expired token, doesn't
 150            require authentication.  Is this a good choice? */
 151         if (getuid() != 0 && !(flags & PAM_CHANGE_EXPIRED_AUTHTOK)) {
 152
 153             /* tell user what is happening */
 154 #define greeting "Changing password for "
 155             Announce = (char *) malloc(sizeof(greeting)+strlen(user));
 156             if (Announce == NULL) {
 157                 _log_err(LOG_CRIT, "password: out of memory");
 158                 return PAM_BUF_ERR;
 159             }
 160             strncpy( Announce, greeting, sizeof(greeting) );
 161             strncpy( Announce+sizeof(greeting)-1, user, strlen(user)+1 );
 162 #undef greeting
 163
 164             set( SMB__OLD_PASSWD, ctrl );
 165             retval = _smb_read_password( pamh, ctrl
 166                                          , Announce
 167                                          , "Current SMB password: "
 168                                          , NULL
 169                                          , _SMB_OLD_AUTHTOK
 170                                          , &pass_old );
 171             free( Announce );
 172
 173             if (retval != PAM_SUCCESS) {
 174                 _log_err( LOG_NOTICE
 175                           , "password - (old) token not obtained" );
 176                 return retval;
 177             }
 178
 179             /* verify that this is the password for this user */
 180
 181             retval = _smb_verify_password( pamh, smb_pwent, pass_old, ctrl );
 182
 183         } else {
 184             pass_old = NULL;
 185             retval = PAM_SUCCESS;           /* root doesn't have to */
 186         }
 187
 188         pass_old = NULL;
 189         return retval;
 190
 191     } else if (flags & PAM_UPDATE_AUTHTOK) {
 192
 193         if (flags & PAM_CHANGE_EXPIRED_AUTHTOK) {
 194             /* NOTE: there is currently no support for password expiring
 195                under Samba. Support will be added here when it becomes
 196                available. */
 197             return PAM_SUCCESS;
 198         }
 199         /*
 200          * obtain the proposed password
 201          */
 202
 203         /*
 204          * get the old token back. NULL was ok only if root [at this
 205          * point we assume that this has already been enforced on a
 206          * previous call to this function].
 207          */
 208
 209         if (off( SMB_NOT_SET_PASS, ctrl )) {
 210             retval = pam_get_item( pamh, PAM_OLDAUTHTOK,
 211                                    (const void **)&pass_old );
 212         } else {
 213             retval = pam_get_data( pamh, _SMB_OLD_AUTHTOK,
 214                                    (const void **)&pass_old );
 215             if (retval == PAM_NO_MODULE_DATA) {
 216                 pass_old = NULL;
 217                 retval = PAM_SUCCESS;
 218             }
 219         }
 220
 221         if (retval != PAM_SUCCESS) {
 222             _log_err( LOG_NOTICE, "password: user not authenticated" );
 223             return retval;
 224         }
 225
 226         /*
 227          * use_authtok is to force the use of a previously entered
 228          * password -- needed for pluggable password strength checking
 229          * or other module stacking
 230          */
 231
 232         if (on( SMB_USE_AUTHTOK, ctrl )) {
 233             set( SMB_USE_FIRST_PASS, ctrl );
 234         }
 235
 236         retval = _smb_read_password( pamh, ctrl
 237                                       , NULL
 238                                       , "Enter new SMB password: "
 239                                       , "Retype new SMB password: "
 240                                       , _SMB_NEW_AUTHTOK
 241                                       , &pass_new );
 242
 243         if (retval != PAM_SUCCESS) {
 244             if (on( SMB_DEBUG, ctrl )) {
 245                 _log_err( LOG_ALERT
 246                           , "password: new password not obtained" );
 247             }
 248             pass_old = NULL;                               /* tidy up */
 249             return retval;
 250         }
 251
 252         /*
 253          * At this point we know who the user is and what they
 254          * propose as their new password. Verify that the new
 255          * password is acceptable.
 256          */
 257
 258         if (pass_new[0] == '\0') {     /* "\0" password = NULL */
 259             pass_new = NULL;
 260         }
 261
 262         retval = _pam_smb_approve_pass(pamh, ctrl, pass_old, pass_new);
 263
 264         if (retval != PAM_SUCCESS) {
 265             _log_err(LOG_NOTICE, "new password not acceptable");
 266             pass_new = pass_old = NULL;               /* tidy up */
 267             return retval;
 268         }
 269
 270         /*
 271          * By reaching here we have approved the passwords and must now
 272          * rebuild the smb password file.
 273          */
 274
 275         /* update the password database */
 276
 277         retval = smb_update_db(pamh, ctrl, user, pass_new);
 278         if (retval == PAM_SUCCESS) {
 279             /* password updated */
 280             _log_err( LOG_NOTICE, "password for (%s/%d) changed by (%s/%d)"
 281                       , user, smb_pwent->smb_userid, uidtoname( getuid() )
 282                       , getuid() );
 283         } else {
 284             _log_err( LOG_ERR, "password change failed for user %s"
 285                       , user );
 286         }
 287
 288         pass_old = pass_new = NULL;
 289         smb_pwent = NULL;
 290
 291     } else {            /* something has broken with the library */
 292
 293         _log_err( LOG_ALERT, "password received unknown request" );
 294         retval = PAM_ABORT;
 295
 296     }
 297
 298     return retval;
 299 }
 300
 301 /* static module data */
 302 #ifdef PAM_STATIC
 303 struct pam_module _pam_smbpass_passwd_modstruct = {
 304      "pam_smbpass",
 305      NULL,
 306      NULL,
 307      NULL,
 308      NULL,
 309      NULL,
 310      pam_sm_chauthtok
 311 };
 312 #endif
 313