pwd_mkdb.c revision 2551 
1/*-
2 * Copyright (c) 1991, 1993, 1994
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 *    must display the following acknowledgement:
15 *	This product includes software developed by the University of
16 *	California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 *    may be used to endorse or promote products derived from this software
19 *    without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#ifndef lint
35static char copyright[] =
36"@(#) Copyright (c) 1991, 1993, 1994\n\
37	The Regents of the University of California.  All rights reserved.\n";
38#endif /* not lint */
39
40#ifndef lint
41static char sccsid[] = "@(#)pwd_mkdb.c	8.5 (Berkeley) 4/20/94";
42#endif /* not lint */
43
44#include <sys/param.h>
45#include <sys/stat.h>
46
47#include <db.h>
48#include <err.h>
49#include <errno.h>
50#include <fcntl.h>
51#include <limits.h>
52#include <pwd.h>
53#include <signal.h>
54#include <stdio.h>
55#include <stdlib.h>
56#include <string.h>
57#include <unistd.h>
58
59#include "pw_scan.h"
60
61#define	INSECURE	1
62#define	SECURE		2
63#define	PERM_INSECURE	(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)
64#define	PERM_SECURE	(S_IRUSR|S_IWUSR)
65
66HASHINFO openinfo = {
67	4096,		/* bsize */
68	32,		/* ffactor */
69	256,		/* nelem */
70	2048 * 1024,	/* cachesize */
71	NULL,		/* hash() */
72	0		/* lorder */
73};
74
75static enum state { FILE_INSECURE, FILE_SECURE, FILE_ORIG } clean;
76static struct passwd pwd;			/* password structure */
77static char *pname;				/* password file name */
78static char prefix[MAXPATHLEN];
79
80void	cleanup __P((void));
81void	error __P((char *));
82void	mv __P((char *, char *));
83int	scan __P((FILE *, struct passwd *));
84void	usage __P((void));
85
86int
87main(argc, argv)
88	int argc;
89	char *argv[];
90{
91	DB *dp, *edp;
92	DBT data, key;
93	FILE *fp, *oldfp;
94	sigset_t set;
95	int ch, cnt, len, makeold, tfd;
96	char *p, *t;
97	char buf[MAX(MAXPATHLEN, LINE_MAX * 2)], tbuf[1024];
98	char buf2[MAXPATHLEN];
99
100	strcpy(prefix, _PATH_PWD);
101	makeold = 0;
102	while ((ch = getopt(argc, argv, "d:pv")) != EOF)
103		switch(ch) {
104		case 'd':
105			strcpy(prefix, optarg);
106			break;
107		case 'p':			/* create V7 "file.orig" */
108			makeold = 1;
109			break;
110		case 'v':                       /* backward compatible */
111			break;
112		case '?':
113		default:
114			usage();
115		}
116	argc -= optind;
117	argv += optind;
118
119	if (argc != 1)
120		usage();
121
122	/*
123	 * This could be changed to allow the user to interrupt.
124	 * Probably not worth the effort.
125	 */
126	sigemptyset(&set);
127	sigaddset(&set, SIGTSTP);
128	sigaddset(&set, SIGHUP);
129	sigaddset(&set, SIGINT);
130	sigaddset(&set, SIGQUIT);
131	sigaddset(&set, SIGTERM);
132	(void)sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
133
134	/* We don't care what the user wants. */
135	(void)umask(0);
136
137	pname = *argv;
138	/* Open the original password file */
139	if (!(fp = fopen(pname, "r")))
140		error(pname);
141
142	/* Open the temporary insecure password database. */
143	(void)snprintf(buf, sizeof(buf), "%s/%s.tmp", prefix, _MP_DB);
144	dp = dbopen(buf,
145	    O_RDWR|O_CREAT|O_EXCL, PERM_INSECURE, DB_HASH, &openinfo);
146	if (dp == NULL)
147		error(buf);
148	clean = FILE_INSECURE;
149
150	/*
151	 * Open file for old password file.  Minor trickiness -- don't want to
152	 * chance the file already existing, since someone (stupidly) might
153	 * still be using this for permission checking.  So, open it first and
154	 * fdopen the resulting fd.  The resulting file should be readable by
155	 * everyone.
156	 */
157	if (makeold) {
158		(void)snprintf(buf, sizeof(buf), "%s.orig", pname);
159		if ((tfd = open(buf,
160		    O_WRONLY|O_CREAT|O_EXCL, PERM_INSECURE)) < 0)
161			error(buf);
162		if ((oldfp = fdopen(tfd, "w")) == NULL)
163			error(buf);
164		clean = FILE_ORIG;
165	}
166
167	/*
168	 * The databases actually contain three copies of the original data.
169	 * Each password file entry is converted into a rough approximation
170	 * of a ``struct passwd'', with the strings placed inline.  This
171	 * object is then stored as the data for three separate keys.  The
172	 * first key * is the pw_name field prepended by the _PW_KEYBYNAME
173	 * character.  The second key is the pw_uid field prepended by the
174	 * _PW_KEYBYUID character.  The third key is the line number in the
175	 * original file prepended by the _PW_KEYBYNUM character.  (The special
176	 * characters are prepended to ensure that the keys do not collide.)
177	 */
178	data.data = (u_char *)buf;
179	key.data = (u_char *)tbuf;
180	for (cnt = 1; scan(fp, &pwd); ++cnt) {
181#define	COMPACT(e)	t = e; while (*p++ = *t++);
182		/* Create insecure data. */
183		p = buf;
184		COMPACT(pwd.pw_name);
185		COMPACT("*");
186		memmove(p, &pwd.pw_uid, sizeof(int));
187		p += sizeof(int);
188		memmove(p, &pwd.pw_gid, sizeof(int));
189		p += sizeof(int);
190		memmove(p, &pwd.pw_change, sizeof(time_t));
191		p += sizeof(time_t);
192		COMPACT(pwd.pw_class);
193		COMPACT(pwd.pw_gecos);
194		COMPACT(pwd.pw_dir);
195		COMPACT(pwd.pw_shell);
196		memmove(p, &pwd.pw_expire, sizeof(time_t));
197		p += sizeof(time_t);
198		data.size = p - buf;
199
200		/* Store insecure by name. */
201		tbuf[0] = _PW_KEYBYNAME;
202		len = strlen(pwd.pw_name);
203		memmove(tbuf + 1, pwd.pw_name, len);
204		key.size = len + 1;
205		if ((dp->put)(dp, &key, &data, R_NOOVERWRITE) == -1)
206			error("put");
207
208		/* Store insecure by number. */
209		tbuf[0] = _PW_KEYBYNUM;
210		memmove(tbuf + 1, &cnt, sizeof(cnt));
211		key.size = sizeof(cnt) + 1;
212		if ((dp->put)(dp, &key, &data, R_NOOVERWRITE) == -1)
213			error("put");
214
215		/* Store insecure by uid. */
216		tbuf[0] = _PW_KEYBYUID;
217		memmove(tbuf + 1, &pwd.pw_uid, sizeof(pwd.pw_uid));
218		key.size = sizeof(pwd.pw_uid) + 1;
219		if ((dp->put)(dp, &key, &data, R_NOOVERWRITE) == -1)
220			error("put");
221
222		/* Create original format password file entry */
223		if (makeold)
224			(void)fprintf(oldfp, "%s:*:%d:%d:%s:%s:%s\n",
225			    pwd.pw_name, pwd.pw_uid, pwd.pw_gid, pwd.pw_gecos,
226			    pwd.pw_dir, pwd.pw_shell);
227	}
228	(void)(dp->close)(dp);
229	if (makeold) {
230		(void)fflush(oldfp);
231		(void)fclose(oldfp);
232	}
233
234	/* Open the temporary encrypted password database. */
235	(void)snprintf(buf, sizeof(buf), "%s/%s.tmp", prefix, _SMP_DB);
236	edp = dbopen(buf,
237	    O_RDWR|O_CREAT|O_EXCL, PERM_SECURE, DB_HASH, &openinfo);
238	if (!edp)
239		error(buf);
240	clean = FILE_SECURE;
241
242	rewind(fp);
243	for (cnt = 1; scan(fp, &pwd); ++cnt) {
244
245		/* Create secure data. */
246		p = buf;
247		COMPACT(pwd.pw_name);
248		COMPACT(pwd.pw_passwd);
249		memmove(p, &pwd.pw_uid, sizeof(int));
250		p += sizeof(int);
251		memmove(p, &pwd.pw_gid, sizeof(int));
252		p += sizeof(int);
253		memmove(p, &pwd.pw_change, sizeof(time_t));
254		p += sizeof(time_t);
255		COMPACT(pwd.pw_class);
256		COMPACT(pwd.pw_gecos);
257		COMPACT(pwd.pw_dir);
258		COMPACT(pwd.pw_shell);
259		memmove(p, &pwd.pw_expire, sizeof(time_t));
260		p += sizeof(time_t);
261		data.size = p - buf;
262
263		/* Store secure by name. */
264		tbuf[0] = _PW_KEYBYNAME;
265		len = strlen(pwd.pw_name);
266		memmove(tbuf + 1, pwd.pw_name, len);
267		key.size = len + 1;
268		if ((dp->put)(edp, &key, &data, R_NOOVERWRITE) == -1)
269			error("put");
270
271		/* Store secure by number. */
272		tbuf[0] = _PW_KEYBYNUM;
273		memmove(tbuf + 1, &cnt, sizeof(cnt));
274		key.size = sizeof(cnt) + 1;
275		if ((dp->put)(edp, &key, &data, R_NOOVERWRITE) == -1)
276			error("put");
277
278		/* Store secure by uid. */
279		tbuf[0] = _PW_KEYBYUID;
280		memmove(tbuf + 1, &pwd.pw_uid, sizeof(pwd.pw_uid));
281		key.size = sizeof(pwd.pw_uid) + 1;
282		if ((dp->put)(edp, &key, &data, R_NOOVERWRITE) == -1)
283			error("put");
284	}
285
286	(void)(edp->close)(edp);
287
288	/* Set master.passwd permissions, in case caller forgot. */
289	(void)fchmod(fileno(fp), S_IRUSR|S_IWUSR);
290	(void)fclose(fp);
291
292	/* Install as the real password files. */
293	(void)snprintf(buf, sizeof(buf), "%s/%s.tmp", prefix, _MP_DB);
294	(void)snprintf(buf2, sizeof(buf2), "%s/%s", prefix, _MP_DB);
295	mv(buf, buf2);
296	(void)snprintf(buf, sizeof(buf), "%s/%s.tmp", prefix, _SMP_DB);
297	(void)snprintf(buf2, sizeof(buf2), "%s/%s", prefix, _SMP_DB);
298	mv(buf, buf2);
299	if (makeold) {
300		(void)snprintf(buf2, sizeof(buf2), "%s/%s", prefix, _PASSWD);
301		(void)snprintf(buf, sizeof(buf), "%s.orig", pname);
302		mv(buf, buf2);
303	}
304	/*
305	 * Move the master password LAST -- chpass(1), passwd(1) and vipw(8)
306	 * all use flock(2) on it to block other incarnations of themselves.
307	 * The rename means that everything is unlocked, as the original file
308	 * can no longer be accessed.
309	 */
310	(void)snprintf(buf, sizeof(buf), "%s/%s", prefix, _MASTERPASSWD);
311	mv(pname, buf);
312	exit(0);
313}
314
315int
316scan(fp, pw)
317	FILE *fp;
318	struct passwd *pw;
319{
320	static int lcnt;
321	static char line[LINE_MAX];
322	char *p;
323
324	if (!fgets(line, sizeof(line), fp))
325		return (0);
326	++lcnt;
327	/*
328	 * ``... if I swallow anything evil, put your fingers down my
329	 * throat...''
330	 *	-- The Who
331	 */
332	if (!(p = strchr(line, '\n'))) {
333		warnx("line too long");
334		goto fmt;
335
336	}
337	*p = '\0';
338	if (!pw_scan(line, pw)) {
339		warnx("at line #%d", lcnt);
340fmt:		errno = EFTYPE;	/* XXX */
341		error(pname);
342	}
343
344	return (1);
345}
346
347void
348mv(from, to)
349	char *from, *to;
350{
351	char buf[MAXPATHLEN];
352
353	if (rename(from, to)) {
354		int sverrno = errno;
355		(void)snprintf(buf, sizeof(buf), "%s to %s", from, to);
356		errno = sverrno;
357		error(buf);
358	}
359}
360
361void
362error(name)
363	char *name;
364{
365
366	warn(name);
367	cleanup();
368	exit(1);
369}
370
371void
372cleanup()
373{
374	char buf[MAXPATHLEN];
375
376	switch(clean) {
377	case FILE_ORIG:
378		(void)snprintf(buf, sizeof(buf), "%s.orig", pname);
379		(void)unlink(buf);
380		/* FALLTHROUGH */
381	case FILE_SECURE:
382		(void)snprintf(buf, sizeof(buf), "%s/%s.tmp", prefix, _SMP_DB);
383		(void)unlink(buf);
384		/* FALLTHROUGH */
385	case FILE_INSECURE:
386		(void)snprintf(buf, sizeof(buf), "%s/%s.tmp", prefix, _MP_DB);
387		(void)unlink(buf);
388	}
389}
390
391void
392usage()
393{
394
395	(void)fprintf(stderr, "usage: pwd_mkdb [-p] [-d <dest dir>] file\n");
396	exit(1);
397}
398