?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / passwdutil / files_attr.c
blob8a250b90df0b8e052d7e7587ed7b3485e6328c45
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright (c) 2016 by Delphix. All rights reserved.
25 */
26
27 #include <sys/types.h>
28 #include <fcntl.h>
29 #include <errno.h>
30 #include <stdlib.h>
31 #include <sys/stat.h>
32 #include <pwd.h>
33 #include <shadow.h>
34 #include <string.h>
35 #include <strings.h>
36 #include <stdlib.h>
37 #include <unistd.h>
38 #include <nss_dbdefs.h>
39 #include <macros.h>
40 #include <syslog.h>
41
42 #include <limits.h> /* LOGNAME_MAX -- max Solaris user name */
43
44 #include "passwdutil.h"
45
46 int files_lock(void);
47 int files_unlock(void);
48 int files_checkhistory(char *user, char *passwd, pwu_repository_t *rep);
49 int files_getattr(char *name, attrlist *item, pwu_repository_t *rep);
50 int files_getpwnam(char *name, attrlist *items, pwu_repository_t *rep,
51 void **buf);
52 int files_update(attrlist *items, pwu_repository_t *rep, void *buf);
53 int files_putpwnam(char *name, char *oldpw, pwu_repository_t *rep, void *buf);
54 int files_user_to_authenticate(char *name, pwu_repository_t *rep,
55 char **auth_user, int *privileged);
56
57 static int files_update_history(char *name, struct spwd *spwd);
58
59 /*
60 * files function pointer table, used by passwdutil_init to initialize
61 * the global Repository-OPerations table "rops"
62 */
63 struct repops files_repops = {
64 files_checkhistory,
65 files_getattr,
66 files_getpwnam,
67 files_update,
68 files_putpwnam,
69 files_user_to_authenticate,
70 files_lock,
71 files_unlock
72 };
73
74 /*
75 * this structure defines the buffer used to keep state between
76 * get/update/put calls
77 */
78 struct pwbuf {
79 int update_history;
80 struct passwd *pwd;
81 char *pwd_scratch;
82 struct spwd *spwd;
83 char *spwd_scratch;
84 char *new_sp_pwdp;
85 };
86
87 /*
88 * We should use sysconf, but there is no sysconf name for SHADOW
89 * so we use these from nss_dbdefs
90 */
91 #define PWD_SCRATCH_SIZE NSS_LINELEN_PASSWD
92 #define SPW_SCRATCH_SIZE NSS_LINELEN_SHADOW
93
94 /*
95 * lock functions for files repository
96 */
97 int
98 files_lock(void)
99 {
100 int res;
101
102 if (lckpwdf()) {
103 switch (errno) {
104 case EINTR:
105 res = PWU_BUSY;
106 break;
107 case EACCES:
108 res = PWU_DENIED;
109 break;
110 case 0:
111 res = PWU_SUCCESS;
112 break;
113 }
114 } else
115 res = PWU_SUCCESS;
116
117 return (res);
118 }
119
120 int
121 files_unlock(void)
122 {
123 if (ulckpwdf())
124 return (PWU_SYSTEM_ERROR);
125
126 return (PWU_SUCCESS);
127 }
128
129 /*
130 * files_privileged
131 *
132 * Are we a privileged user with regard to the files repository?
133 */
134 int
135 files_privileged(void)
136 {
137 return (getuid() == 0);
138 }
139
140 /*
141 *
142 * private_getpwnam_r()
143 *
144 * A private implementation of getpwnam_r which does *not* fall back to
145 * other services possibly defined in nsswitch.conf
146 *
147 * behaves like getpwnam_r().
148 */
149 struct passwd *
150 private_getpwnam_r(const char *name, struct passwd *result, char *buffer,
151 int buflen)
152 {
153 FILE *fp;
154 int found;
155
156 if ((fp = fopen(PASSWD, "rF")) == NULL)
157 return (NULL);
158
159 found = 0;
160 while (!found && fgetpwent_r(fp, result, buffer, buflen) != NULL) {
161 if (strcmp(name, result->pw_name) == 0)
162 found = 1;
163 }
164
165 (void) fclose(fp);
166
167 if (!found) {
168 (void) memset(buffer, 0, buflen);
169 (void) memset(result, 0, sizeof (*result));
170 return (NULL);
171 }
172
173 return (result);
174 }
175
176 /*
177 * private_getspnam_r()
178 *
179 * A private implementation of getspnam_r which does *not* fall back to
180 * other services possibly defined in nsswitch.conf.
181 *
182 * Behaves like getspnam_r(). Since we use fgetspent_t(), all numeric
183 * fields that are undefined in /etc/shadow will be set to -1.
184 *
185 */
186 struct spwd *
187 private_getspnam_r(const char *name, struct spwd *result, char *buffer,
188 int buflen)
189 {
190 FILE *fp;
191 int found;
192
193 fp = fopen(SHADOW, "rF");
194 if (fp == NULL)
195 return (NULL);
196
197 found = 0;
198 while (!found && fgetspent_r(fp, result, buffer, buflen) != NULL) {
199 if (strcmp(name, result->sp_namp) == 0)
200 found = 1;
201 }
202
203 (void) fclose(fp);
204
205 if (!found) {
206 (void) memset(buffer, 0, buflen);
207 (void) memset(result, 0, sizeof (*result));
208 return (NULL);
209 }
210 return (result);
211 }
212
213 /*
214 * files_getpwnam(name, items, rep, buf)
215 *
216 */
217 /*ARGSUSED*/
218 int
219 files_getpwnam(char *name, attrlist *items, pwu_repository_t *rep, void **buf)
220 {
221 attrlist *p;
222 struct pwbuf *pwbuf;
223 int err = PWU_SUCCESS;
224
225 *buf = calloc(1, sizeof (struct pwbuf));
226 pwbuf = (struct pwbuf *)*buf;
227 if (pwbuf == NULL)
228 return (PWU_NOMEM);
229
230 /*
231 * determine which password structure (/etc/passwd or /etc/shadow)
232 * we need for the items we need to update
233 */
234 for (p = items; p != NULL; p = p->next) {
235 switch (p->type) {
236 case ATTR_NAME:
237 case ATTR_UID:
238 case ATTR_GID:
239 case ATTR_AGE:
240 case ATTR_COMMENT:
241 case ATTR_GECOS:
242 case ATTR_HOMEDIR:
243 case ATTR_SHELL:
244 if (pwbuf->pwd == NULL) {
245 pwbuf->pwd = malloc(sizeof (struct passwd));
246 if (pwbuf->pwd == NULL) {
247 err = PWU_NOMEM;
248 goto error;
249 }
250 }
251 break;
252 case ATTR_PASSWD:
253 case ATTR_PASSWD_SERVER_POLICY:
254 case ATTR_LSTCHG:
255 case ATTR_MIN:
256 case ATTR_MAX:
257 case ATTR_WARN:
258 case ATTR_INACT:
259 case ATTR_EXPIRE:
260 case ATTR_FLAG:
261 case ATTR_LOCK_ACCOUNT:
262 case ATTR_EXPIRE_PASSWORD:
263 case ATTR_FAILED_LOGINS:
264 case ATTR_INCR_FAILED_LOGINS:
265 case ATTR_RST_FAILED_LOGINS:
266 case ATTR_NOLOGIN_ACCOUNT:
267 case ATTR_UNLOCK_ACCOUNT:
268 if (pwbuf->spwd == NULL) {
269 pwbuf->spwd = malloc(sizeof (struct spwd));
270 if (pwbuf->spwd == NULL) {
271 err = PWU_NOMEM;
272 goto error;
273 }
274 }
275 break;
276 default:
277 /*
278 * Some other repository might have different values
279 * so we ignore those.
280 */
281 break;
282 }
283 }
284
285 if (pwbuf->pwd) {
286 if ((pwbuf->pwd_scratch = malloc(PWD_SCRATCH_SIZE)) == NULL) {
287 err = PWU_NOMEM;
288 goto error;
289 }
290 if (private_getpwnam_r(name, pwbuf->pwd, pwbuf->pwd_scratch,
291 PWD_SCRATCH_SIZE) == NULL) {
292 err = PWU_NOT_FOUND;
293 goto error;
294 }
295 }
296
297 if (pwbuf->spwd) {
298 if ((pwbuf->spwd_scratch = malloc(SPW_SCRATCH_SIZE)) == NULL) {
299 err = PWU_NOMEM;
300 goto error;
301 }
302 if (private_getspnam_r(name, pwbuf->spwd, pwbuf->spwd_scratch,
303 SPW_SCRATCH_SIZE) == NULL) {
304 err = PWU_NOT_FOUND;
305 goto error;
306 }
307 }
308
309 return (PWU_SUCCESS);
310 error:
311 if (pwbuf->pwd) free(pwbuf->pwd);
312 if (pwbuf->pwd_scratch) free(pwbuf->pwd_scratch);
313 if (pwbuf->spwd) free(pwbuf->spwd);
314 if (pwbuf->spwd_scratch) free(pwbuf->spwd_scratch);
315 free(pwbuf);
316 *buf = NULL;
317
318 return (err);
319 }
320
321 /*
322 * int files_user_to_authenticate(name, rep, auth_user, privileged)
323 * Determine which user needs to be authenticated. For files, the
324 * possible return values are:
325 * PWU_NOT_FOUND
326 * PWU_SUCCESS and (auth_user == NULL || auth_user = user)
327 * PWU_DENIED
328 * PWU_NOMEM
329 */
330 /*ARGSUSED*/
331 int
332 files_user_to_authenticate(char *user, pwu_repository_t *rep,
333 char **auth_user, int *privileged)
334 {
335 struct pwbuf *pwbuf;
336 int res;
337 attrlist attr_tmp[1] = { { ATTR_UID, NULL, NULL } };
338
339 /* check to see if target user is present in files */
340 res = files_getpwnam(user, &attr_tmp[0], rep, (void **)&pwbuf);
341 if (res != PWU_SUCCESS)
342 return (res);
343
344 if (files_privileged()) {
345 *auth_user = NULL;
346 *privileged = 1;
347 res = PWU_SUCCESS;
348 } else {
349 *privileged = 0;
350 if (getuid() == pwbuf->pwd->pw_uid) {
351 if ((*auth_user = strdup(user)) == NULL) {
352 res = PWU_NOMEM;
353 } else {
354 res = PWU_SUCCESS;
355 }
356 } else {
357 res = PWU_DENIED;
358 }
359 }
360
361 if (pwbuf->pwd) free(pwbuf->pwd);
362 if (pwbuf->pwd_scratch) free(pwbuf->pwd_scratch);
363 if (pwbuf->spwd) free(pwbuf->spwd);
364 if (pwbuf->spwd_scratch) free(pwbuf->spwd_scratch);
365 free(pwbuf);
366
367 return (res);
368 }
369
370 /*
371 * Password history file format:
372 * user:crypw1: ... crypwn: such that n <= MAXHISTORY
373 */
374 #define HISTORY "/etc/security/passhistory"
375 #define HISTEMP "/etc/security/pwhistemp"
376 #define OHISTORY "/etc/security/opwhistory"
377 #define HISTMODE S_IRUSR /* mode to create history file */
378 /*
379 * XXX
380 * 3*LOGNAME_MAX just in case there are long user names.
381 * Traditionally Solaris LOGNAME_MAX (_POSIX_LOGIN_NAME_MAX) is 13,
382 * but some sites often user more.
383 * If LOGNAME_MAX ever becomes reasonable (128) and actually enforced,
384 * fix up here.
385 * XXX
386 */
387 #define MAX_LOGNAME (3 * LOGNAME_MAX)
388
389 /*
390 * files_checkhistory - check if a user's new password is in the user's
391 * old password history.
392 *
393 * Entry
394 * user = username.
395 * passwd = new clear text password.
396 *
397 * Exit
398 * PWU_SUCCESS, passwd found in user's old password history.
399 * The caller should only be interested and fail if
400 * PWU_SUCCESS is returned.
401 * PWU_NOT_FOUND, passwd not in user's old password history.
402 * PWU_errors, PWU_ errors from other routines.
403 *
404 */
405 int
406 files_checkhistory(char *user, char *passwd, pwu_repository_t *rep)
407 {
408 attrlist attr;
409 int res;
410
411 attr.type = ATTR_HISTORY;
412 attr.data.val_s = NULL;
413 attr.next = NULL;
414
415 debug("files_checkhistory(user=%s)", user);
416
417 /*
418 * XXX
419 * This depends on the underlying files_getattr implementation
420 * treating user not found in backing store or no history as
421 * an error.
422 * XXX
423 */
424
425 if ((res = files_getattr(user, &attr, rep)) == PWU_SUCCESS) {
426 char *s;
427 char *crypt_passwd;
428 int histsize;
429 char *last = attr.data.val_s;
430
431 if ((histsize = def_getint("HISTORY=", DEFHISTORY)) == 0) {
432 debug("files_checkhistory: no history requested");
433 res = PWU_NOT_FOUND;
434 goto out;
435 }
436
437 debug("files_checkhistory: histsize = %d", histsize);
438 if (histsize > MAXHISTORY)
439 histsize = MAXHISTORY;
440
441 debug("line to test\n\t%s", last);
442
443 /* compare crypt_passwd to attr.data.val_s strings. */
444 res = PWU_NOT_FOUND;
445 while ((histsize-- > 0) &&
446 (((s = strtok_r(NULL, ":", &last)) != NULL) &&
447 (*s != '\n'))) {
448
449 crypt_passwd = crypt(passwd, s);
450 debug("files_checkhistory: user_pw=%s, history_pw=%s",
451 crypt_passwd, s);
452 if (strcmp(crypt_passwd, s) == 0) {
453 res = PWU_SUCCESS;
454 break;
455 }
456 }
457 debug("files_checkhistory(%s, %s) = %d", user, crypt_passwd,
458 res);
459 }
460 out:
461 if (attr.data.val_s != NULL)
462 free(attr.data.val_s);
463
464 return (res);
465 }
466
467 /*
468 * files_getattr(name, items, rep)
469 *
470 * Get attributes specified in list 'items'
471 */
472 int
473 files_getattr(char *name, attrlist *items, pwu_repository_t *rep)
474 {
475 struct pwbuf *pwbuf;
476 struct passwd *pw;
477 struct spwd *spw;
478 attrlist *w;
479 int res;
480
481 res = files_getpwnam(name, items, rep, (void **)&pwbuf);
482 if (res != PWU_SUCCESS)
483 return (res);
484
485 pw = pwbuf->pwd;
486 spw = pwbuf->spwd;
487
488 for (w = items; res == PWU_SUCCESS && w != NULL; w = w->next) {
489 switch (w->type) {
490 case ATTR_NAME:
491 if ((w->data.val_s = strdup(pw->pw_name)) == NULL)
492 res = PWU_NOMEM;
493 break;
494 case ATTR_COMMENT:
495 if ((w->data.val_s = strdup(pw->pw_comment)) == NULL)
496 res = PWU_NOMEM;
497 break;
498 case ATTR_GECOS:
499 if ((w->data.val_s = strdup(pw->pw_gecos)) == NULL)
500 res = PWU_NOMEM;
501 break;
502 case ATTR_HOMEDIR:
503 if ((w->data.val_s = strdup(pw->pw_dir)) == NULL)
504 res = PWU_NOMEM;
505 break;
506 case ATTR_SHELL:
507 if ((w->data.val_s = strdup(pw->pw_shell)) == NULL)
508 res = PWU_NOMEM;
509 break;
510 /*
511 * Nothing special needs to be done for
512 * server policy
513 */
514 case ATTR_PASSWD:
515 case ATTR_PASSWD_SERVER_POLICY:
516 if ((w->data.val_s = strdup(spw->sp_pwdp)) == NULL)
517 res = PWU_NOMEM;
518 break;
519 case ATTR_AGE:
520 if ((w->data.val_s = strdup(pw->pw_age)) == NULL)
521 res = PWU_NOMEM;
522 break;
523 case ATTR_REP_NAME:
524 if ((w->data.val_s = strdup("files")) == NULL)
525 res = PWU_NOMEM;
526 break;
527 case ATTR_HISTORY: {
528 FILE *history;
529 char buf[MAX_LOGNAME + MAXHISTORY +
530 (MAXHISTORY * CRYPT_MAXCIPHERTEXTLEN)+1];
531 char *s, *s1;
532
533 debug("files_getattr: Get password history for %s ",
534 name);
535
536 if ((history = fopen(HISTORY, "rF")) == NULL) {
537 debug("files_getattr: %s not found", HISTORY);
538 res = PWU_OPEN_FAILED;
539 goto getattr_exit;
540 }
541 res = PWU_NOT_FOUND;
542 while ((s = fgets(buf, sizeof (buf), history)) !=
543 NULL) {
544 s1 = strchr(s, ':');
545 if (s1 != NULL) {
546 *s1 = '\0';
547 } else {
548 res = PWU_NOT_FOUND;
549 break;
550 }
551 #ifdef DEBUG
552 debug("got history line for %s", s);
553 #endif /* DEBUG */
554 if (strcmp(s, name) == 0) {
555 /* found user */
556 if ((items->data.val_s =
557 strdup(s1+1)) == NULL)
558 res = PWU_NOMEM;
559 else
560 res = PWU_SUCCESS;
561 break;
562 }
563 }
564 (void) fclose(history);
565 break;
566 }
567
568 /* integer values */
569 case ATTR_UID:
570 w->data.val_i = pw->pw_uid;
571 break;
572 case ATTR_GID:
573 w->data.val_i = pw->pw_gid;
574 break;
575 case ATTR_LSTCHG:
576 w->data.val_i = spw->sp_lstchg;
577 break;
578 case ATTR_MIN:
579 w->data.val_i = spw->sp_min;
580 break;
581 case ATTR_MAX:
582 w->data.val_i = spw->sp_max;
583 break;
584 case ATTR_WARN:
585 w->data.val_i = spw->sp_warn;
586 break;
587 case ATTR_INACT:
588 w->data.val_i = spw->sp_inact;
589 break;
590 case ATTR_EXPIRE:
591 w->data.val_i = spw->sp_expire;
592 break;
593 case ATTR_FLAG:
594 w->data.val_i = spw->sp_flag;
595 break;
596 case ATTR_FAILED_LOGINS:
597 w->data.val_i = spw->sp_flag & FAILCOUNT_MASK;
598 break;
599 default:
600 break;
601 }
602 }
603
604 getattr_exit:
605 if (pwbuf->pwd) free(pwbuf->pwd);
606 if (pwbuf->pwd_scratch) free(pwbuf->pwd_scratch);
607 if (pwbuf->spwd) free(pwbuf->spwd);
608 if (pwbuf->spwd_scratch) free(pwbuf->spwd_scratch);
609 free(pwbuf);
610
611 return (res);
612 }
613
614 /*
615 * max_present(list)
616 *
617 * see if attribute ATTR_MAX, with value != -1, is present in
618 * attribute-list "list".
619 *
620 * returns 1 if present, 0 otherwise.
621 */
622 static int
623 max_present(attrlist *list)
624 {
625 while (list != NULL)
626 if (list->type == ATTR_MAX && list->data.val_i != -1)
627 return (1);
628 else
629 list = list->next;
630
631 return (0);
632 }
633
634 /*
635 * files_update(items, rep, buf)
636 *
637 * update the information in buf with the attributes specified in
638 * items.
639 */
640 /*ARGSUSED*/
641 int
642 files_update(attrlist *items, pwu_repository_t *rep, void *buf)
643 {
644 struct pwbuf *pwbuf = (struct pwbuf *)buf;
645 struct passwd *pw;
646 struct spwd *spw;
647 attrlist *p;
648 int aging_needed = 0;
649 int aging_set = 0;
650 int disable_aging;
651 char *pword;
652 int len;
653
654 pw = pwbuf->pwd;
655 spw = pwbuf->spwd;
656 pwbuf->update_history = 0;
657
658 /*
659 * if sp_max==0 : disable passwd aging after updating the password
660 */
661 disable_aging = (spw != NULL && spw->sp_max == 0);
662
663 for (p = items; p != NULL; p = p->next) {
664 switch (p->type) {
665 case ATTR_NAME:
666 break; /* We are able to handle this, but... */
667 case ATTR_UID:
668 pw->pw_uid = (uid_t)p->data.val_i;
669 break;
670 case ATTR_GID:
671 pw->pw_gid = (gid_t)p->data.val_i;
672 break;
673 case ATTR_AGE:
674 pw->pw_age = p->data.val_s;
675 break;
676 case ATTR_COMMENT:
677 pw->pw_comment = p->data.val_s;
678 break;
679 case ATTR_GECOS:
680 pw->pw_gecos = p->data.val_s;
681 break;
682 case ATTR_HOMEDIR:
683 pw->pw_dir = p->data.val_s;
684 break;
685 case ATTR_SHELL:
686 pw->pw_shell = p->data.val_s;
687 break;
688
689 /*
690 * Nothing special needs to be done for
691 * server policy
692 */
693 case ATTR_PASSWD:
694 case ATTR_PASSWD_SERVER_POLICY:
695 /*
696 * There is a special case only for files: if the
697 * password is to be deleted (-d to passwd),
698 * p->data.val_s will be NULL.
699 */
700 if (p->data.val_s == NULL) {
701 spw->sp_pwdp = "";
702 } else {
703 char *salt = NULL;
704 char *hash = NULL;
705
706 salt = crypt_gensalt(spw->sp_pwdp, pw);
707
708 if (salt == NULL) {
709 if (errno == ENOMEM)
710 return (PWU_NOMEM);
711 /* algorithm problem? */
712 syslog(LOG_AUTH | LOG_ALERT,
713 "passwdutil: crypt_gensalt %m");
714 return (PWU_UPDATE_FAILED);
715 }
716 hash = crypt(p->data.val_s, salt);
717 free(salt);
718 if (hash == NULL) {
719 errno = ENOMEM;
720 return (PWU_NOMEM);
721 }
722 pword = strdup(hash);
723 if (pword == NULL) {
724 errno = ENOMEM;
725 return (PWU_NOMEM);
726 }
727
728 if (pwbuf->new_sp_pwdp)
729 free(pwbuf->new_sp_pwdp);
730 pwbuf->new_sp_pwdp = pword;
731 spw->sp_pwdp = pword;
732 aging_needed = 1;
733 pwbuf->update_history = 1;
734 }
735 spw->sp_flag &= ~FAILCOUNT_MASK; /* reset count */
736 spw->sp_lstchg = DAY_NOW_32;
737 break;
738 case ATTR_LOCK_ACCOUNT:
739 if (spw->sp_pwdp == NULL) {
740 spw->sp_pwdp = LOCKSTRING;
741 } else if ((strncmp(spw->sp_pwdp, LOCKSTRING,
742 sizeof (LOCKSTRING)-1) != 0) &&
743 (strcmp(spw->sp_pwdp, NOLOGINSTRING) != 0)) {
744 len = sizeof (LOCKSTRING)-1 +
745 strlen(spw->sp_pwdp) + 1;
746 pword = malloc(len);
747 if (pword == NULL) {
748 errno = ENOMEM;
749 return (PWU_NOMEM);
750 }
751 (void) strlcpy(pword, LOCKSTRING, len);
752 (void) strlcat(pword, spw->sp_pwdp, len);
753 if (pwbuf->new_sp_pwdp)
754 free(pwbuf->new_sp_pwdp);
755 pwbuf->new_sp_pwdp = pword;
756 spw->sp_pwdp = pword;
757 }
758 spw->sp_lstchg = DAY_NOW_32;
759 break;
760 case ATTR_UNLOCK_ACCOUNT:
761 if (spw->sp_pwdp != NULL &&
762 strncmp(spw->sp_pwdp, LOCKSTRING,
763 sizeof (LOCKSTRING)-1) == 0) {
764 (void) strcpy(spw->sp_pwdp, spw->sp_pwdp +
765 sizeof (LOCKSTRING)-1);
766 }
767 spw->sp_lstchg = DAY_NOW_32;
768 break;
769 case ATTR_NOLOGIN_ACCOUNT:
770 spw->sp_pwdp = NOLOGINSTRING;
771 if (pwbuf->new_sp_pwdp) {
772 free(pwbuf->new_sp_pwdp);
773 pwbuf->new_sp_pwdp = NULL;
774 }
775 spw->sp_lstchg = DAY_NOW_32;
776 break;
777 case ATTR_EXPIRE_PASSWORD:
778 spw->sp_lstchg = 0;
779 break;
780 case ATTR_LSTCHG:
781 spw->sp_lstchg = p->data.val_i;
782 break;
783 case ATTR_MIN:
784 if (spw->sp_max == -1 &&
785 p->data.val_i != -1 && max_present(p->next) == 0)
786 return (PWU_AGING_DISABLED);
787 spw->sp_min = p->data.val_i;
788 aging_set = 1;
789 break;
790 case ATTR_MAX:
791 if (p->data.val_i == -1) {
792 /* Turn aging off -> Reset min and warn too */
793
794 spw->sp_min = -1;
795 spw->sp_warn = -1;
796 } else {
797 /* Turn aging on */
798
799 if (spw->sp_min == -1) {
800 /*
801 * If minage has not been set with
802 * a command-line option, we set it
803 * to zero.
804 */
805 spw->sp_min = 0;
806 }
807
808 /*
809 * If aging was turned off, we update lstchg.
810 *
811 * We take care not to update lstchg if the
812 * user has no password, otherwise the user
813 * might not be required to provide a password
814 * the next time they log-in.
815 *
816 * Also, if lstchg != -1 (i.e., not set in
817 * /etc/shadow), we keep the old value.
818 */
819 if (spw->sp_max == -1 &&
820 spw->sp_pwdp != NULL && *spw->sp_pwdp &&
821 spw->sp_lstchg == -1) {
822 spw->sp_lstchg = DAY_NOW_32;
823 }
824 }
825
826 spw->sp_max = p->data.val_i;
827
828 aging_set = 1;
829
830 break;
831 case ATTR_WARN:
832 if (spw->sp_max == -1 && p->data.val_i != -1 &&
833 max_present(p->next) == 0)
834 return (PWU_AGING_DISABLED);
835 spw->sp_warn = p->data.val_i;
836 break;
837 case ATTR_INACT:
838 spw->sp_inact = p->data.val_i;
839 break;
840 case ATTR_EXPIRE:
841 spw->sp_expire = p->data.val_i;
842 break;
843 case ATTR_FLAG:
844 spw->sp_flag = p->data.val_i;
845 break;
846 case ATTR_INCR_FAILED_LOGINS:
847 {
848 int count = (spw->sp_flag & FAILCOUNT_MASK) + 1;
849 spw->sp_flag &= ~FAILCOUNT_MASK;
850 spw->sp_flag |= min(FAILCOUNT_MASK, count);
851 p->data.val_i = count;
852 }
853 break;
854 case ATTR_RST_FAILED_LOGINS:
855 p->data.val_i = spw->sp_flag & FAILCOUNT_MASK;
856 spw->sp_flag &= ~FAILCOUNT_MASK;
857 break;
858 default:
859 break;
860 }
861 }
862
863 /*
864 * What should the new aging values look like?
865 *
866 * There are a number of different conditions
867 *
868 * a) aging is already configured: don't touch it
869 *
870 * b) disable_aging is set: disable aging
871 *
872 * c) aging is not configured: turn on default aging;
873 *
874 * b) and c) of course only if aging_needed and !aging_set.
875 * (i.e., password changed, and aging values not changed)
876 */
877
878 if (spw != NULL && spw->sp_max <= 0) {
879 /* a) aging not yet configured */
880 if (aging_needed && !aging_set) {
881 if (disable_aging) {
882 /* b) turn off aging */
883 spw->sp_min = spw->sp_max = spw->sp_warn = -1;
884 } else {
885 /* c) */
886 turn_on_default_aging(spw);
887 }
888 }
889 }
890
891 return (PWU_SUCCESS);
892 }
893
894 /*
895 * files_update_shadow(char *name, struct spwd *spwd)
896 *
897 * update the shadow password file SHADOW to contain the spwd structure
898 * "spwd" for user "name"
899 */
900 int
901 files_update_shadow(char *name, struct spwd *spwd)
902 {
903 struct stat64 stbuf;
904 FILE *dst;
905 FILE *src;
906 struct spwd cur;
907 char buf[SPW_SCRATCH_SIZE];
908 int tempfd;
909 mode_t filemode;
910 int result = -1;
911 int err = PWU_SUCCESS;
912
913 /* Mode of the shadow file should be 400 or 000 */
914 if (stat64(SHADOW, &stbuf) < 0) {
915 err = PWU_STAT_FAILED;
916 goto shadow_exit;
917 }
918
919 /* copy mode from current shadow file (0400 or 0000) */
920 filemode = stbuf.st_mode & S_IRUSR;
921
922 /*
923 * we can't specify filemodes to fopen(), and we SHOULD NOT
924 * set umask in multi-thread safe libraries, so we use
925 * a combination of open() and fdopen()
926 */
927 tempfd = open(SHADTEMP, O_WRONLY|O_CREAT|O_TRUNC, filemode);
928 if (tempfd < 0) {
929 err = PWU_OPEN_FAILED;
930 goto shadow_exit;
931 }
932 (void) fchown(tempfd, (uid_t)0, stbuf.st_gid);
933
934 if ((dst = fdopen(tempfd, "wF")) == NULL) {
935 err = PWU_OPEN_FAILED;
936 goto shadow_exit;
937 }
938
939 if ((src = fopen(SHADOW, "rF")) == NULL) {
940 err = PWU_OPEN_FAILED;
941 (void) fclose(dst);
942 (void) unlink(SHADTEMP);
943 goto shadow_exit;
944 }
945
946 /*
947 * copy old shadow to temporary file while replacing the entry
948 * that matches "name".
949 */
950 while (fgetspent_r(src, &cur, buf, sizeof (buf)) != NULL) {
951
952 if (strcmp(cur.sp_namp, name) == 0)
953 result = putspent(spwd, dst);
954 else
955 result = putspent(&cur, dst);
956
957 if (result != 0) {
958 err = PWU_WRITE_FAILED;
959 (void) fclose(src);
960 (void) fclose(dst);
961 goto shadow_exit;
962 }
963 }
964
965 (void) fclose(src);
966
967 if (fclose(dst) != 0) {
968 /*
969 * Something went wrong (ENOSPC for example). Don't
970 * use the resulting temporary file!
971 */
972 err = PWU_CLOSE_FAILED;
973 (void) unlink(SHADTEMP);
974 goto shadow_exit;
975 }
976
977 /*
978 * Rename stmp to shadow:
979 * 1. make sure /etc/oshadow is gone
980 * 2. ln /etc/shadow /etc/oshadow
981 * 3. mv /etc/stmp /etc/shadow
982 */
983 if (unlink(OSHADOW) && access(OSHADOW, 0) == 0) {
984 err = PWU_UPDATE_FAILED;
985 (void) unlink(SHADTEMP);
986 goto shadow_exit;
987 }
988
989 if (link(SHADOW, OSHADOW) == -1) {
990 err = PWU_UPDATE_FAILED;
991 (void) unlink(SHADTEMP);
992 goto shadow_exit;
993 }
994
995 if (rename(SHADTEMP, SHADOW) == -1) {
996 err = PWU_UPDATE_FAILED;
997 (void) unlink(SHADTEMP);
998 goto shadow_exit;
999 }
1000 (void) unlink(OSHADOW);
1001
1002 shadow_exit:
1003 return (err);
1004 }
1005
1006 int
1007 files_update_passwd(char *name, struct passwd *pwd)
1008 {
1009 struct stat64 stbuf;
1010 FILE *src, *dst;
1011 int tempfd;
1012 struct passwd cur;
1013 char buf[PWD_SCRATCH_SIZE];
1014 int result;
1015 int err = PWU_SUCCESS;
1016
1017 if (stat64(PASSWD, &stbuf) < 0) {
1018 err = PWU_STAT_FAILED;
1019 goto passwd_exit;
1020 }
1021
1022 /* see files_update_shadow() for open()+fdopen() rationale */
1023
1024 if ((tempfd = open(PASSTEMP, O_WRONLY|O_CREAT|O_TRUNC, 0600)) < 0) {
1025 err = PWU_OPEN_FAILED;
1026 goto passwd_exit;
1027 }
1028 if ((dst = fdopen(tempfd, "wF")) == NULL) {
1029 err = PWU_OPEN_FAILED;
1030 goto passwd_exit;
1031 }
1032 if ((src = fopen(PASSWD, "rF")) == NULL) {
1033 err = PWU_OPEN_FAILED;
1034 (void) fclose(dst);
1035 (void) unlink(PASSTEMP);
1036 goto passwd_exit;
1037 }
1038
1039 /*
1040 * copy old password entries to temporary file while replacing
1041 * the entry that matches "name"
1042 */
1043 while (fgetpwent_r(src, &cur, buf, sizeof (buf)) != NULL) {
1044 if (strcmp(cur.pw_name, name) == 0)
1045 result = putpwent(pwd, dst);
1046 else
1047 result = putpwent(&cur, dst);
1048 if (result != 0) {
1049 err = PWU_WRITE_FAILED;
1050 (void) fclose(src);
1051 (void) fclose(dst);
1052 goto passwd_exit;
1053 }
1054 }
1055
1056 (void) fclose(src);
1057 if (fclose(dst) != 0) {
1058 err = PWU_CLOSE_FAILED;
1059 goto passwd_exit; /* Don't trust the temporary file */
1060 }
1061
1062 /* Rename temp to passwd */
1063 if (unlink(OPASSWD) && access(OPASSWD, 0) == 0) {
1064 err = PWU_UPDATE_FAILED;
1065 (void) unlink(PASSTEMP);
1066 goto passwd_exit;
1067 }
1068
1069 if (link(PASSWD, OPASSWD) == -1) {
1070 err = PWU_UPDATE_FAILED;
1071 (void) unlink(PASSTEMP);
1072 goto passwd_exit;
1073 }
1074
1075 if (rename(PASSTEMP, PASSWD) == -1) {
1076 err = PWU_UPDATE_FAILED;
1077 (void) unlink(PASSTEMP);
1078 goto passwd_exit;
1079 }
1080
1081 (void) chmod(PASSWD, 0644);
1082
1083 passwd_exit:
1084 return (err);
1085
1086 }
1087
1088 /*
1089 * files_putpwnam(name, oldpw, rep, buf)
1090 *
1091 * store the password attributes contained in "buf" in /etc/passwd and
1092 * /etc/shadow.
1093 */
1094 /*ARGSUSED*/
1095 int
1096 files_putpwnam(char *name, char *oldpw, pwu_repository_t *rep, void *buf)
1097 {
1098 struct pwbuf *pwbuf = (struct pwbuf *)buf;
1099 int result = PWU_SUCCESS;
1100
1101 if (pwbuf->pwd) {
1102 result = files_update_passwd(name, pwbuf->pwd);
1103 }
1104
1105 if (result == PWU_SUCCESS && pwbuf->spwd) {
1106 if (pwbuf->update_history != 0) {
1107 debug("update_history = %d", pwbuf->update_history);
1108 result = files_update_history(name, pwbuf->spwd);
1109 } else {
1110 debug("no password change");
1111 }
1112 if (result == PWU_SUCCESS) {
1113 result = files_update_shadow(name, pwbuf->spwd);
1114 }
1115 }
1116
1117 if (pwbuf->pwd) {
1118 (void) memset(pwbuf->pwd, 0, sizeof (struct passwd));
1119 (void) memset(pwbuf->pwd_scratch, 0, PWD_SCRATCH_SIZE);
1120 free(pwbuf->pwd);
1121 free(pwbuf->pwd_scratch);
1122 }
1123 if (pwbuf->spwd) {
1124 (void) memset(pwbuf->spwd, 0, sizeof (struct spwd));
1125 (void) memset(pwbuf->spwd_scratch, 0, SPW_SCRATCH_SIZE);
1126 free(pwbuf->spwd);
1127 free(pwbuf->spwd_scratch);
1128 }
1129 if (pwbuf->new_sp_pwdp) {
1130 free(pwbuf->new_sp_pwdp);
1131 }
1132
1133 return (result);
1134 }
1135
1136 /*
1137 * NOTE: This is all covered under the repository lock held for updating
1138 * passwd(4) and shadow(4).
1139 */
1140 int
1141 files_update_history(char *name, struct spwd *spwd)
1142 {
1143 int histsize;
1144 int tmpfd;
1145 FILE *src; /* history database file */
1146 FILE *dst; /* temp history database being updated */
1147 struct stat64 statbuf;
1148 char buf[MAX_LOGNAME + MAXHISTORY +
1149 (MAXHISTORY * CRYPT_MAXCIPHERTEXTLEN)+1];
1150 int found;
1151
1152 if ((histsize = def_getint("HISTORY=", DEFHISTORY)) == 0) {
1153 debug("files_update_history(%s) no history, unlinking", name);
1154 (void) unlink(HISTORY);
1155 return (PWU_SUCCESS); /* no history update defined */
1156 }
1157 debug("files_update_history(%s, %s) histsize = %d", name, spwd->sp_pwdp,
1158 histsize);
1159
1160 if (histsize > MAXHISTORY)
1161 histsize = MAXHISTORY;
1162 if ((tmpfd = open(HISTEMP, O_WRONLY|O_CREAT|O_TRUNC, HISTMODE)) < 0) {
1163 return (PWU_OPEN_FAILED);
1164 }
1165 (void) fchown(tmpfd, (uid_t)0, (gid_t)0);
1166
1167 /* get ready to copy */
1168 if (((src = fopen(HISTORY, "rF")) == NULL) &&
1169 (errno != ENOENT)) {
1170 (void) unlink(HISTEMP);
1171 return (PWU_OPEN_FAILED);
1172 }
1173 if ((dst = fdopen(tmpfd, "wF")) == NULL) {
1174 (void) fclose(src);
1175 (void) unlink(HISTEMP);
1176 return (PWU_OPEN_FAILED);
1177 }
1178
1179 /* Copy and update if found. Add if not found. */
1180
1181 found = 0;
1182
1183 while ((src != NULL) &&
1184 (fgets(buf, sizeof (buf), src) != NULL)) {
1185 char *user;
1186 char *last;
1187
1188 /* get username field */
1189 user = strtok_r(buf, ":", &last);
1190
1191 #ifdef DEBUG
1192 debug("files_update_history: read=\"%s\"", user);
1193 #endif /* DEBUG */
1194
1195 if (strcmp(user, name) == 0) {
1196 char *crypt;
1197 int i;
1198
1199 /* found user, update */
1200 found++;
1201 (void) fprintf(dst, "%s:%s:", name, spwd->sp_pwdp);
1202 debug("files_update_history: update user\n"
1203 "\t%s:%s:", name, spwd->sp_pwdp);
1204
1205 /* get old crypted password history */
1206 for (i = 0; i < MAXHISTORY-1; i++) {
1207 crypt = strtok_r(NULL, ":", &last);
1208 if (crypt == NULL ||
1209 *crypt == '\n') {
1210 break;
1211 }
1212 (void) fprintf(dst, "%s:", crypt);
1213 debug("\t%d = %s:", i+1, crypt);
1214 }
1215 (void) fprintf(dst, "\n");
1216 } else {
1217
1218 /* copy other users to updated file */
1219 (void) fprintf(dst, "%s:%s", user, last);
1220 #ifdef DEBUG
1221 debug("files_update_history: copy line %s",
1222 user);
1223 #endif /* DEBUG */
1224 }
1225 }
1226
1227 if (found == 0) {
1228
1229 /* user not found, add to history file */
1230 (void) fprintf(dst, "%s:%s:\n", name, spwd->sp_pwdp);
1231 debug("files_update_history: add line\n"
1232 "\t%s:%s:", name, spwd->sp_pwdp);
1233 }
1234
1235 (void) fclose(src);
1236
1237 /* If something messed up in file system, loose the update */
1238 if (fclose(dst) != 0) {
1239
1240 debug("files_update_history: update file close failed %d",
1241 errno);
1242 (void) unlink(HISTEMP);
1243 return (PWU_CLOSE_FAILED);
1244 }
1245
1246 /*
1247 * rename history to ohistory,
1248 * rename tmp to history,
1249 * unlink ohistory.
1250 */
1251
1252 (void) unlink(OHISTORY);
1253
1254 if (stat64(OHISTORY, &statbuf) == 0 ||
1255 ((src != NULL) && (link(HISTORY, OHISTORY) != 0)) ||
1256 rename(HISTEMP, HISTORY) != 0) {
1257
1258 /* old history won't go away, loose the update */
1259 debug("files_update_history: update file rename failed %d",
1260 errno);
1261 (void) unlink(HISTEMP);
1262 return (PWU_UPDATE_FAILED);
1263 }
1264
1265 (void) unlink(OHISTORY);
1266 return (PWU_SUCCESS);
1267 }
unleashed repo fork