waf: Check for Linux has 32-bit credential calls
[Samba.git] / source3 / pam_smbpass / pam_smb_passwd.c
blob1adebe2e898a5a053299671cee67aafecf8295a9
1 /*
2 Unix SMB/CIFS implementation.
3 Use PAM to update user passwords in the local SAM
4 Copyright (C) Steve Langasek 1998-2003
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 /* indicate the following groups are defined */
22 #define PAM_SM_PASSWORD
24 #include "includes.h"
26 /* This is only used in the Sun implementation. FIXME: we really
27 want a define here that distinguishes between the Solaris PAM
28 and others (including FreeBSD). */
30 #ifndef LINUX
31 #if defined(HAVE_SECURITY_PAM_APPL_H)
32 #include <security/pam_appl.h>
33 #elif defined(HAVE_PAM_PAM_APPL_H)
34 #include <pam/pam_appl.h>
35 #endif
36 #endif
38 #if defined(HAVE_SECURITY_PAM_MODULES_H)
39 #include <security/pam_modules.h>
40 #elif defined(HAVE_PAM_PAM_MODULES_H)
41 #include <pam/pam_modules.h>
42 #endif
44 #include "general.h"
46 #include "support.h"
48 static int smb_update_db( pam_handle_t *pamh, int ctrl, const char *user, const char *pass_new )
50 int retval;
51 char *err_str = NULL;
52 char *msg_str = NULL;
54 retval = NT_STATUS_IS_OK(local_password_change(user, LOCAL_SET_PASSWORD, pass_new,
55 &err_str,
56 &msg_str));
58 if (!retval) {
59 if (err_str) {
60 make_remark(pamh, ctrl, PAM_ERROR_MSG, err_str );
63 /* FIXME: what value is appropriate here? */
64 retval = PAM_AUTHTOK_ERR;
65 } else {
66 if (msg_str) {
67 make_remark(pamh, ctrl, PAM_TEXT_INFO, msg_str );
69 retval = PAM_SUCCESS;
72 SAFE_FREE(err_str);
73 SAFE_FREE(msg_str);
74 return retval;
78 /* data tokens */
80 #define _SMB_OLD_AUTHTOK "-SMB-OLD-PASS"
81 #define _SMB_NEW_AUTHTOK "-SMB-NEW-PASS"
84 * FUNCTION: pam_sm_chauthtok()
86 * This function is called twice by the PAM library, once with
87 * PAM_PRELIM_CHECK set, and then again with PAM_UPDATE_AUTHTOK set. With
88 * Linux-PAM, these two passes generally involve first checking the old
89 * token and then changing the token. This is what we do here.
91 * Having obtained a new password. The function updates the
92 * SMB_PASSWD_FILE file (normally, $(LIBDIR)/smbpasswd).
95 int pam_sm_chauthtok(pam_handle_t *pamh, int flags,
96 int argc, const char **argv)
98 unsigned int ctrl;
99 int retval;
101 struct samu *sampass = NULL;
102 void (*oldsig_handler)(int);
103 const char *user;
104 char *pass_old = NULL;
105 char *pass_new = NULL;
106 TALLOC_CTX *frame = talloc_stackframe();
108 /* Samba initialization. */
110 ctrl = set_ctrl(pamh, flags, argc, argv);
113 * First get the name of a user. No need to do anything if we can't
114 * determine this.
117 retval = pam_get_user( pamh, &user, "Username: " );
118 if (retval != PAM_SUCCESS) {
119 if (on( SMB_DEBUG, ctrl )) {
120 _log_err(pamh, LOG_DEBUG, "password: could not identify user");
122 TALLOC_FREE(frame);
123 return retval;
125 if (on( SMB_DEBUG, ctrl )) {
126 _log_err(pamh, LOG_DEBUG, "username [%s] obtained", user);
129 if (geteuid() != 0) {
130 _log_err(pamh, LOG_DEBUG, "Cannot access samba password database, not running as root.");
131 TALLOC_FREE(frame);
132 return PAM_AUTHINFO_UNAVAIL;
135 /* Getting into places that might use LDAP -- protect the app
136 from a SIGPIPE it's not expecting */
137 oldsig_handler = CatchSignal(SIGPIPE, SIG_IGN);
139 if (!initialize_password_db(False, NULL)) {
140 _log_err(pamh, LOG_ALERT, "Cannot access samba password database" );
141 CatchSignal(SIGPIPE, oldsig_handler);
142 TALLOC_FREE(frame);
143 return PAM_AUTHINFO_UNAVAIL;
146 /* obtain user record */
147 if ( !(sampass = samu_new( NULL )) ) {
148 CatchSignal(SIGPIPE, oldsig_handler);
149 TALLOC_FREE(frame);
150 return nt_status_to_pam(NT_STATUS_NO_MEMORY);
153 if (!pdb_getsampwnam(sampass,user)) {
154 _log_err(pamh, LOG_ALERT, "Failed to find entry for user %s.", user);
155 CatchSignal(SIGPIPE, oldsig_handler);
156 TALLOC_FREE(frame);
157 return PAM_USER_UNKNOWN;
159 if (on( SMB_DEBUG, ctrl )) {
160 _log_err(pamh, LOG_DEBUG, "Located account for %s", user);
163 if (flags & PAM_PRELIM_CHECK) {
165 * obtain and verify the current password (OLDAUTHTOK) for
166 * the user.
169 char *Announce;
171 if (_smb_blankpasswd( ctrl, sampass )) {
173 TALLOC_FREE(sampass);
174 CatchSignal(SIGPIPE, oldsig_handler);
175 TALLOC_FREE(frame);
176 return PAM_SUCCESS;
179 /* Password change by root, or for an expired token, doesn't
180 require authentication. Is this a good choice? */
181 if (getuid() != 0 && !(flags & PAM_CHANGE_EXPIRED_AUTHTOK)) {
183 /* tell user what is happening */
184 if (asprintf(&Announce, "Changing password for %s", user) == -1) {
185 _log_err(pamh, LOG_CRIT, "password: out of memory");
186 TALLOC_FREE(sampass);
187 CatchSignal(SIGPIPE, oldsig_handler);
188 TALLOC_FREE(frame);
189 return PAM_BUF_ERR;
192 set( SMB__OLD_PASSWD, ctrl );
193 retval = _smb_read_password( pamh, ctrl, Announce, "Current SMB password: ",
194 NULL, _SMB_OLD_AUTHTOK, &pass_old );
195 SAFE_FREE( Announce );
197 if (retval != PAM_SUCCESS) {
198 _log_err(pamh, LOG_NOTICE,
199 "password - (old) token not obtained");
200 TALLOC_FREE(sampass);
201 CatchSignal(SIGPIPE, oldsig_handler);
202 TALLOC_FREE(frame);
203 return retval;
206 /* verify that this is the password for this user */
208 retval = _smb_verify_password( pamh, sampass, pass_old, ctrl );
210 } else {
211 pass_old = NULL;
212 retval = PAM_SUCCESS; /* root doesn't have to */
215 pass_old = NULL;
216 TALLOC_FREE(sampass);
217 CatchSignal(SIGPIPE, oldsig_handler);
218 TALLOC_FREE(frame);
219 return retval;
221 } else if (flags & PAM_UPDATE_AUTHTOK) {
224 * obtain the proposed password
228 * get the old token back. NULL was ok only if root [at this
229 * point we assume that this has already been enforced on a
230 * previous call to this function].
233 if (off( SMB_NOT_SET_PASS, ctrl )) {
234 retval = _pam_get_item( pamh, PAM_OLDAUTHTOK,
235 &pass_old );
236 } else {
237 retval = _pam_get_data( pamh, _SMB_OLD_AUTHTOK,
238 &pass_old );
239 if (retval == PAM_NO_MODULE_DATA) {
240 pass_old = NULL;
241 retval = PAM_SUCCESS;
245 if (retval != PAM_SUCCESS) {
246 _log_err(pamh, LOG_NOTICE, "password: user not authenticated");
247 TALLOC_FREE(sampass);
248 CatchSignal(SIGPIPE, oldsig_handler);
249 TALLOC_FREE(frame);
250 return retval;
254 * use_authtok is to force the use of a previously entered
255 * password -- needed for pluggable password strength checking
256 * or other module stacking
259 if (on( SMB_USE_AUTHTOK, ctrl )) {
260 set( SMB_USE_FIRST_PASS, ctrl );
263 retval = _smb_read_password( pamh, ctrl
264 , NULL
265 , "Enter new SMB password: "
266 , "Retype new SMB password: "
267 , _SMB_NEW_AUTHTOK
268 , &pass_new );
270 if (retval != PAM_SUCCESS) {
271 if (on( SMB_DEBUG, ctrl )) {
272 _log_err(pamh, LOG_ALERT,
273 "password: new password not obtained");
275 pass_old = NULL; /* tidy up */
276 TALLOC_FREE(sampass);
277 CatchSignal(SIGPIPE, oldsig_handler);
278 TALLOC_FREE(frame);
279 return retval;
283 * At this point we know who the user is and what they
284 * propose as their new password. Verify that the new
285 * password is acceptable.
288 if (pass_new[0] == '\0') { /* "\0" password = NULL */
289 pass_new = NULL;
292 retval = _pam_smb_approve_pass(pamh, ctrl, pass_old, pass_new);
294 if (retval != PAM_SUCCESS) {
295 _log_err(pamh, LOG_NOTICE, "new password not acceptable");
296 pass_new = pass_old = NULL; /* tidy up */
297 TALLOC_FREE(sampass);
298 CatchSignal(SIGPIPE, oldsig_handler);
299 TALLOC_FREE(frame);
300 return retval;
304 * By reaching here we have approved the passwords and must now
305 * rebuild the smb password file.
308 /* update the password database */
310 retval = smb_update_db(pamh, ctrl, user, pass_new);
311 if (retval == PAM_SUCCESS) {
312 uid_t uid;
314 /* password updated */
315 if (!sid_to_uid(pdb_get_user_sid(sampass), &uid)) {
316 _log_err(pamh, LOG_NOTICE,
317 "Unable to get uid for user %s",
318 pdb_get_username(sampass));
319 _log_err(pamh, LOG_NOTICE, "password for (%s) changed by (%s/%d)",
320 user, uidtoname(getuid()), getuid());
321 } else {
322 _log_err(pamh, LOG_NOTICE, "password for (%s/%d) changed by (%s/%d)",
323 user, uid, uidtoname(getuid()), getuid());
325 } else {
326 _log_err(pamh, LOG_ERR, "password change failed for user %s", user);
329 pass_old = pass_new = NULL;
330 if (sampass) {
331 TALLOC_FREE(sampass);
332 sampass = NULL;
335 } else { /* something has broken with the library */
337 _log_err(pamh, LOG_ALERT, "password received unknown request");
338 retval = PAM_ABORT;
342 if (sampass) {
343 TALLOC_FREE(sampass);
344 sampass = NULL;
347 TALLOC_FREE(sampass);
348 CatchSignal(SIGPIPE, oldsig_handler);
349 TALLOC_FREE(frame);
350 return retval;
353 /* static module data */
354 #ifdef PAM_STATIC
355 struct pam_module _pam_smbpass_passwd_modstruct = {
356 "pam_smbpass",
357 NULL,
358 NULL,
359 NULL,
360 NULL,
361 NULL,
362 pam_sm_chauthtok
364 #endif