1/*
2 * Copyright (c) 2010, 2011, Oracle America, Inc.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following
12 * disclaimer in the documentation and/or other materials
13 * provided with the distribution.
14 * * Neither the name of the "Oracle America, Inc." nor the names of its
15 * contributors may be used to endorse or promote products derived
16 * from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
23 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
25 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31/*
32 * auth_unix.c, Implements UNIX style authentication parameters.
33 *
34 * The system is very weak. The client uses no encryption for it's
35 * credentials and only sends null verifiers. The server sends backs
36 * null verifiers or optionally a verifier that suggests a new short hand
37 * for the credentials.
38 */
39
40#include <errno.h>
41#include <limits.h>
42#include <stdbool.h>
43#include <stdio.h>
44#include <string.h>
45#include <unistd.h>
46#include <libintl.h>
47#include <sys/param.h>
48#include <wchar.h>
49
50#include <rpc/types.h>
51#include <rpc/xdr.h>
52#include <rpc/auth.h>
53#include <rpc/auth_unix.h>
54
55
56/*
57 * Unix authenticator operations vector
58 */
59static void authunix_nextverf (AUTH *);
60static bool_t authunix_marshal (AUTH *, XDR *);
61static bool_t authunix_validate (AUTH *, struct opaque_auth *);
62static bool_t authunix_refresh (AUTH *);
63static void authunix_destroy (AUTH *);
64
65static const struct auth_ops auth_unix_ops = {
66 authunix_nextverf,
67 authunix_marshal,
68 authunix_validate,
69 authunix_refresh,
70 authunix_destroy
71};
72
73/*
74 * This struct is pointed to by the ah_private field of an auth_handle.
75 */
76struct audata {
77 struct opaque_auth au_origcred; /* original credentials */
78 struct opaque_auth au_shcred; /* short hand cred */
79 u_long au_shfaults; /* short hand cache faults */
80 char au_marshed[MAX_AUTH_BYTES];
81 u_int au_mpos; /* xdr pos at end of marshed */
82};
83#define AUTH_PRIVATE(auth) ((struct audata *)auth->ah_private)
84
85static bool_t marshal_new_auth (AUTH *) internal_function;
86
87
88/*
89 * Create a unix style authenticator.
90 * Returns an auth handle with the given stuff in it.
91 */
92AUTH *
93authunix_create (char *machname, uid_t uid, gid_t gid, int len,
94 gid_t *aup_gids)
95{
96 struct authunix_parms aup;
97 char mymem[MAX_AUTH_BYTES];
98 struct timeval now;
99 XDR xdrs;
100 AUTH *auth;
101 struct audata *au;
102
103 /*
104 * Allocate and set up auth handle
105 */
106 auth = (AUTH *) mem_alloc (sizeof (*auth));
107 au = (struct audata *) mem_alloc (sizeof (*au));
108 if (auth == NULL || au == NULL)
109 {
110no_memory:
111 (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
112 mem_free (auth, sizeof (*auth));
113 mem_free (au, sizeof (*au));
114 return NULL;
115 }
116 auth->ah_ops = (struct auth_ops *) &auth_unix_ops;
117 auth->ah_private = (caddr_t) au;
118 auth->ah_verf = au->au_shcred = _null_auth;
119 au->au_shfaults = 0;
120
121 /*
122 * fill in param struct from the given params
123 */
124 (void) __gettimeofday (&now, (struct timezone *) 0);
125 aup.aup_time = now.tv_sec;
126 aup.aup_machname = machname;
127 aup.aup_uid = uid;
128 aup.aup_gid = gid;
129 aup.aup_len = (u_int) len;
130 aup.aup_gids = aup_gids;
131
132 /*
133 * Serialize the parameters into origcred
134 */
135 xdrmem_create (&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE);
136 if (!xdr_authunix_parms (&xdrs, &aup))
137 abort ();
138 au->au_origcred.oa_length = len = XDR_GETPOS (&xdrs);
139 au->au_origcred.oa_flavor = AUTH_UNIX;
140 au->au_origcred.oa_base = mem_alloc ((u_int) len);
141 if (au->au_origcred.oa_base == NULL)
142 goto no_memory;
143 memcpy(au->au_origcred.oa_base, mymem, (u_int) len);
144
145 /*
146 * set auth handle to reflect new cred.
147 */
148 auth->ah_cred = au->au_origcred;
149 marshal_new_auth (auth);
150 return auth;
151}
152libc_hidden_nolink_sunrpc (authunix_create, GLIBC_2_0)
153
154/*
155 * Returns an auth handle with parameters determined by doing lots of
156 * syscalls.
157 */
158AUTH *
159authunix_create_default (void)
160{
161 char machname[MAX_MACHINE_NAME + 1];
162
163 if (__gethostname (machname, MAX_MACHINE_NAME) == -1)
164 abort ();
165 machname[MAX_MACHINE_NAME] = 0;
166 uid_t uid = __geteuid ();
167 gid_t gid = __getegid ();
168
169 int max_nr_groups;
170 /* When we have to try a second time, do not use alloca() again. We
171 might have reached the stack limit already. */
172 bool retry = false;
173 again:
174 /* Ask the kernel how many groups there are exactly. Note that we
175 might have to redo all this if the number of groups has changed
176 between the two calls. */
177 max_nr_groups = __getgroups (0, NULL);
178
179 /* Just some random reasonable stack limit. */
180#define ALLOCA_LIMIT (1024 / sizeof (gid_t))
181 gid_t *gids = NULL;
182 if (max_nr_groups < ALLOCA_LIMIT && ! retry)
183 gids = (gid_t *) alloca (max_nr_groups * sizeof (gid_t));
184 else
185 {
186 gids = (gid_t *) malloc (max_nr_groups * sizeof (gid_t));
187 if (gids == NULL)
188 return NULL;
189 }
190
191 int len = __getgroups (max_nr_groups, gids);
192 if (len == -1)
193 {
194 if (errno == EINVAL)
195 {
196 /* New groups added in the meantime. Try again. */
197 if (max_nr_groups >= ALLOCA_LIMIT || retry)
198 free (gids);
199 retry = true;
200 goto again;
201 }
202 /* No other error can happen. */
203 abort ();
204 }
205
206 /* This braindamaged Sun code forces us here to truncate the
207 list of groups to NGRPS members since the code in
208 authuxprot.c transforms a fixed array. Grrr. */
209 AUTH *result = authunix_create (machname, uid, gid, MIN (NGRPS, len), gids);
210
211 if (max_nr_groups >= ALLOCA_LIMIT || retry)
212 free (gids);
213
214 return result;
215}
216#ifdef EXPORT_RPC_SYMBOLS
217libc_hidden_def (authunix_create_default)
218#else
219libc_hidden_nolink_sunrpc (authunix_create_default, GLIBC_2_0)
220#endif
221
222/*
223 * authunix operations
224 */
225
226static void
227authunix_nextverf (AUTH *auth)
228{
229 /* no action necessary */
230}
231
232static bool_t
233authunix_marshal (AUTH *auth, XDR *xdrs)
234{
235 struct audata *au = AUTH_PRIVATE (auth);
236
237 return XDR_PUTBYTES (xdrs, au->au_marshed, au->au_mpos);
238}
239
240static bool_t
241authunix_validate (AUTH *auth, struct opaque_auth *verf)
242{
243 struct audata *au;
244 XDR xdrs;
245
246 if (verf->oa_flavor == AUTH_SHORT)
247 {
248 au = AUTH_PRIVATE (auth);
249 xdrmem_create (&xdrs, verf->oa_base, verf->oa_length, XDR_DECODE);
250
251 if (au->au_shcred.oa_base != NULL)
252 {
253 mem_free (au->au_shcred.oa_base,
254 au->au_shcred.oa_length);
255 au->au_shcred.oa_base = NULL;
256 }
257 if (xdr_opaque_auth (&xdrs, &au->au_shcred))
258 {
259 auth->ah_cred = au->au_shcred;
260 }
261 else
262 {
263 xdrs.x_op = XDR_FREE;
264 (void) xdr_opaque_auth (&xdrs, &au->au_shcred);
265 au->au_shcred.oa_base = NULL;
266 auth->ah_cred = au->au_origcred;
267 }
268 marshal_new_auth (auth);
269 }
270 return TRUE;
271}
272
273static bool_t
274authunix_refresh (AUTH *auth)
275{
276 struct audata *au = AUTH_PRIVATE (auth);
277 struct authunix_parms aup;
278 struct timeval now;
279 XDR xdrs;
280 int stat;
281
282 if (auth->ah_cred.oa_base == au->au_origcred.oa_base)
283 {
284 /* there is no hope. Punt */
285 return FALSE;
286 }
287 au->au_shfaults++;
288
289 /* first deserialize the creds back into a struct authunix_parms */
290 aup.aup_machname = NULL;
291 aup.aup_gids = (gid_t *) NULL;
292 xdrmem_create (&xdrs, au->au_origcred.oa_base,
293 au->au_origcred.oa_length, XDR_DECODE);
294 stat = xdr_authunix_parms (&xdrs, &aup);
295 if (!stat)
296 goto done;
297
298 /* update the time and serialize in place */
299 (void) __gettimeofday (&now, (struct timezone *) 0);
300 aup.aup_time = now.tv_sec;
301 xdrs.x_op = XDR_ENCODE;
302 XDR_SETPOS (&xdrs, 0);
303 stat = xdr_authunix_parms (&xdrs, &aup);
304 if (!stat)
305 goto done;
306 auth->ah_cred = au->au_origcred;
307 marshal_new_auth (auth);
308done:
309 /* free the struct authunix_parms created by deserializing */
310 xdrs.x_op = XDR_FREE;
311 (void) xdr_authunix_parms (&xdrs, &aup);
312 XDR_DESTROY (&xdrs);
313 return stat;
314}
315
316static void
317authunix_destroy (AUTH *auth)
318{
319 struct audata *au = AUTH_PRIVATE (auth);
320
321 mem_free (au->au_origcred.oa_base, au->au_origcred.oa_length);
322
323 if (au->au_shcred.oa_base != NULL)
324 mem_free (au->au_shcred.oa_base, au->au_shcred.oa_length);
325
326 mem_free (auth->ah_private, sizeof (struct audata));
327
328 if (auth->ah_verf.oa_base != NULL)
329 mem_free (auth->ah_verf.oa_base, auth->ah_verf.oa_length);
330
331 mem_free ((caddr_t) auth, sizeof (*auth));
332}
333
334/*
335 * Marshals (pre-serializes) an auth struct.
336 * sets private data, au_marshed and au_mpos
337 */
338static bool_t
339internal_function
340marshal_new_auth (AUTH *auth)
341{
342 XDR xdr_stream;
343 XDR *xdrs = &xdr_stream;
344 struct audata *au = AUTH_PRIVATE (auth);
345
346 xdrmem_create (xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
347 if ((!xdr_opaque_auth (xdrs, &(auth->ah_cred))) ||
348 (!xdr_opaque_auth (xdrs, &(auth->ah_verf))))
349 perror (_("auth_unix.c: Fatal marshalling problem"));
350 else
351 au->au_mpos = XDR_GETPOS (xdrs);
352
353 XDR_DESTROY (xdrs);
354
355 return TRUE;
356}
357