auth_unix.c revision 241141 
1/*	$NetBSD: auth_unix.c,v 1.18 2000/07/06 03:03:30 christos Exp $	*/
2
3/*
4 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
5 * unrestricted use provided that this legend is included on all tape
6 * media and as a part of the software program in whole or part.  Users
7 * may copy or modify Sun RPC without charge, but are not authorized
8 * to license or distribute it to anyone else except as part of a product or
9 * program developed by the user.
10 *
11 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
12 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
13 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
14 *
15 * Sun RPC is provided with no support and without any obligation on the
16 * part of Sun Microsystems, Inc. to assist in its use, correction,
17 * modification or enhancement.
18 *
19 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
20 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
21 * OR ANY PART THEREOF.
22 *
23 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
24 * or profits or other special, indirect and consequential damages, even if
25 * Sun has been advised of the possibility of such damages.
26 *
27 * Sun Microsystems, Inc.
28 * 2550 Garcia Avenue
29 * Mountain View, California  94043
30 */
31
32#if defined(LIBC_SCCS) && !defined(lint)
33static char *sccsid2 = "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro";
34static char *sccsid = "@(#)auth_unix.c	2.2 88/08/01 4.0 RPCSRC";
35#endif
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD: head/lib/libc/rpc/auth_unix.c 241141 2012-10-02 19:00:56Z pfg $");
38
39/*
40 * auth_unix.c, Implements UNIX style authentication parameters.
41 *
42 * Copyright (C) 1984, Sun Microsystems, Inc.
43 *
44 * The system is very weak.  The client uses no encryption for it's
45 * credentials and only sends null verifiers.  The server sends backs
46 * null verifiers or optionally a verifier that suggests a new short hand
47 * for the credentials.
48 *
49 */
50
51#include "namespace.h"
52#include "reentrant.h"
53#include <sys/param.h>
54
55#include <assert.h>
56#include <err.h>
57#include <stdio.h>
58#include <stdlib.h>
59#include <unistd.h>
60#include <string.h>
61
62#include <rpc/types.h>
63#include <rpc/xdr.h>
64#include <rpc/auth.h>
65#include <rpc/auth_unix.h>
66#include "un-namespace.h"
67#include "mt_misc.h"
68
69/* auth_unix.c */
70static void authunix_nextverf (AUTH *);
71static bool_t authunix_marshal (AUTH *, XDR *);
72static bool_t authunix_validate (AUTH *, struct opaque_auth *);
73static bool_t authunix_refresh (AUTH *, void *);
74static void authunix_destroy (AUTH *);
75static void marshal_new_auth (AUTH *);
76static struct auth_ops *authunix_ops (void);
77
78/*
79 * This struct is pointed to by the ah_private field of an auth_handle.
80 */
81struct audata {
82	struct opaque_auth	au_origcred;	/* original credentials */
83	struct opaque_auth	au_shcred;	/* short hand cred */
84	u_long			au_shfaults;	/* short hand cache faults */
85	char			au_marshed[MAX_AUTH_BYTES];
86	u_int			au_mpos;	/* xdr pos at end of marshed */
87};
88#define	AUTH_PRIVATE(auth)	((struct audata *)auth->ah_private)
89
90/*
91 * Create a unix style authenticator.
92 * Returns an auth handle with the given stuff in it.
93 */
94AUTH *
95authunix_create(machname, uid, gid, len, aup_gids)
96	char *machname;
97	uid_t uid;
98	gid_t gid;
99	int len;
100	gid_t *aup_gids;
101{
102	struct authunix_parms aup;
103	char mymem[MAX_AUTH_BYTES];
104	struct timeval now;
105	XDR xdrs;
106	AUTH *auth;
107	struct audata *au;
108
109	/*
110	 * Allocate and set up auth handle
111	 */
112	au = NULL;
113	auth = mem_alloc(sizeof(*auth));
114#ifndef _KERNEL
115	if (auth == NULL) {
116		warnx("authunix_create: out of memory");
117		goto cleanup_authunix_create;
118	}
119#endif
120	au = mem_alloc(sizeof(*au));
121#ifndef _KERNEL
122	if (au == NULL) {
123		warnx("authunix_create: out of memory");
124		goto cleanup_authunix_create;
125	}
126#endif
127	auth->ah_ops = authunix_ops();
128	auth->ah_private = (caddr_t)au;
129	auth->ah_verf = au->au_shcred = _null_auth;
130	au->au_shfaults = 0;
131	au->au_origcred.oa_base = NULL;
132
133	/*
134	 * fill in param struct from the given params
135	 */
136	(void)gettimeofday(&now, NULL);
137	aup.aup_time = now.tv_sec;
138	aup.aup_machname = machname;
139	aup.aup_uid = uid;
140	aup.aup_gid = gid;
141	aup.aup_len = (u_int)len;
142	aup.aup_gids = aup_gids;
143
144	/*
145	 * Serialize the parameters into origcred
146	 */
147	xdrmem_create(&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE);
148	if (! xdr_authunix_parms(&xdrs, &aup))
149		abort();
150	au->au_origcred.oa_length = len = XDR_GETPOS(&xdrs);
151	au->au_origcred.oa_flavor = AUTH_UNIX;
152#ifdef _KERNEL
153	au->au_origcred.oa_base = mem_alloc((u_int) len);
154#else
155	if ((au->au_origcred.oa_base = mem_alloc((u_int) len)) == NULL) {
156		warnx("authunix_create: out of memory");
157		goto cleanup_authunix_create;
158	}
159#endif
160	memmove(au->au_origcred.oa_base, mymem, (size_t)len);
161
162	/*
163	 * set auth handle to reflect new cred.
164	 */
165	auth->ah_cred = au->au_origcred;
166	marshal_new_auth(auth);
167	return (auth);
168#ifndef _KERNEL
169 cleanup_authunix_create:
170	if (auth)
171		mem_free(auth, sizeof(*auth));
172	if (au) {
173		if (au->au_origcred.oa_base)
174			mem_free(au->au_origcred.oa_base, (u_int)len);
175		mem_free(au, sizeof(*au));
176	}
177	return (NULL);
178#endif
179}
180
181/*
182 * Returns an auth handle with parameters determined by doing lots of
183 * syscalls.
184 */
185AUTH *
186authunix_create_default()
187{
188	AUTH *auth;
189	int ngids;
190	long ngids_max;
191	char machname[MAXHOSTNAMELEN + 1];
192	uid_t uid;
193	gid_t gid;
194	gid_t *gids;
195
196	ngids_max = sysconf(_SC_NGROUPS_MAX) + 1;
197	gids = malloc(sizeof(gid_t) * ngids_max);
198	if (gids == NULL)
199		return (NULL);
200
201	if (gethostname(machname, sizeof machname) == -1)
202		abort();
203	machname[sizeof(machname) - 1] = 0;
204	uid = geteuid();
205	gid = getegid();
206	if ((ngids = getgroups(ngids_max, gids)) < 0)
207		abort();
208	if (ngids > NGRPS)
209		ngids = NGRPS;
210	auth = authunix_create(machname, uid, gid, ngids, gids);
211	free(gids);
212	return (auth);
213}
214
215/*
216 * authunix operations
217 */
218
219/* ARGSUSED */
220static void
221authunix_nextverf(auth)
222	AUTH *auth;
223{
224	/* no action necessary */
225}
226
227static bool_t
228authunix_marshal(auth, xdrs)
229	AUTH *auth;
230	XDR *xdrs;
231{
232	struct audata *au;
233
234	assert(auth != NULL);
235	assert(xdrs != NULL);
236
237	au = AUTH_PRIVATE(auth);
238	return (XDR_PUTBYTES(xdrs, au->au_marshed, au->au_mpos));
239}
240
241static bool_t
242authunix_validate(auth, verf)
243	AUTH *auth;
244	struct opaque_auth *verf;
245{
246	struct audata *au;
247	XDR xdrs;
248
249	assert(auth != NULL);
250	assert(verf != NULL);
251
252	if (verf->oa_flavor == AUTH_SHORT) {
253		au = AUTH_PRIVATE(auth);
254		xdrmem_create(&xdrs, verf->oa_base, verf->oa_length,
255		    XDR_DECODE);
256
257		if (au->au_shcred.oa_base != NULL) {
258			mem_free(au->au_shcred.oa_base,
259			    au->au_shcred.oa_length);
260			au->au_shcred.oa_base = NULL;
261		}
262		if (xdr_opaque_auth(&xdrs, &au->au_shcred)) {
263			auth->ah_cred = au->au_shcred;
264		} else {
265			xdrs.x_op = XDR_FREE;
266			(void)xdr_opaque_auth(&xdrs, &au->au_shcred);
267			au->au_shcred.oa_base = NULL;
268			auth->ah_cred = au->au_origcred;
269		}
270		marshal_new_auth(auth);
271	}
272	return (TRUE);
273}
274
275static bool_t
276authunix_refresh(AUTH *auth, void *dummy)
277{
278	struct audata *au = AUTH_PRIVATE(auth);
279	struct authunix_parms aup;
280	struct timeval now;
281	XDR xdrs;
282	int stat;
283
284	assert(auth != NULL);
285
286	if (auth->ah_cred.oa_base == au->au_origcred.oa_base) {
287		/* there is no hope.  Punt */
288		return (FALSE);
289	}
290	au->au_shfaults ++;
291
292	/* first deserialize the creds back into a struct authunix_parms */
293	aup.aup_machname = NULL;
294	aup.aup_gids = NULL;
295	xdrmem_create(&xdrs, au->au_origcred.oa_base,
296	    au->au_origcred.oa_length, XDR_DECODE);
297	stat = xdr_authunix_parms(&xdrs, &aup);
298	if (! stat)
299		goto done;
300
301	/* update the time and serialize in place */
302	(void)gettimeofday(&now, NULL);
303	aup.aup_time = now.tv_sec;
304	xdrs.x_op = XDR_ENCODE;
305	XDR_SETPOS(&xdrs, 0);
306	stat = xdr_authunix_parms(&xdrs, &aup);
307	if (! stat)
308		goto done;
309	auth->ah_cred = au->au_origcred;
310	marshal_new_auth(auth);
311done:
312	/* free the struct authunix_parms created by deserializing */
313	xdrs.x_op = XDR_FREE;
314	(void)xdr_authunix_parms(&xdrs, &aup);
315	XDR_DESTROY(&xdrs);
316	return (stat);
317}
318
319static void
320authunix_destroy(auth)
321	AUTH *auth;
322{
323	struct audata *au;
324
325	assert(auth != NULL);
326
327	au = AUTH_PRIVATE(auth);
328	mem_free(au->au_origcred.oa_base, au->au_origcred.oa_length);
329
330	if (au->au_shcred.oa_base != NULL)
331		mem_free(au->au_shcred.oa_base, au->au_shcred.oa_length);
332
333	mem_free(auth->ah_private, sizeof(struct audata));
334
335	if (auth->ah_verf.oa_base != NULL)
336		mem_free(auth->ah_verf.oa_base, auth->ah_verf.oa_length);
337
338	mem_free(auth, sizeof(*auth));
339}
340
341/*
342 * Marshals (pre-serializes) an auth struct.
343 * sets private data, au_marshed and au_mpos
344 */
345static void
346marshal_new_auth(auth)
347	AUTH *auth;
348{
349	XDR	xdr_stream;
350	XDR	*xdrs = &xdr_stream;
351	struct audata *au;
352
353	assert(auth != NULL);
354
355	au = AUTH_PRIVATE(auth);
356	xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
357	if ((! xdr_opaque_auth(xdrs, &(auth->ah_cred))) ||
358	    (! xdr_opaque_auth(xdrs, &(auth->ah_verf))))
359		warnx("auth_none.c - Fatal marshalling problem");
360	else
361		au->au_mpos = XDR_GETPOS(xdrs);
362	XDR_DESTROY(xdrs);
363}
364
365static struct auth_ops *
366authunix_ops()
367{
368	static struct auth_ops ops;
369
370	/* VARIABLES PROTECTED BY ops_lock: ops */
371
372	mutex_lock(&ops_lock);
373	if (ops.ah_nextverf == NULL) {
374		ops.ah_nextverf = authunix_nextverf;
375		ops.ah_marshal = authunix_marshal;
376		ops.ah_validate = authunix_validate;
377		ops.ah_refresh = authunix_refresh;
378		ops.ah_destroy = authunix_destroy;
379	}
380	mutex_unlock(&ops_lock);
381	return (&ops);
382}
383