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 <time.h>
47 #include <libintl.h>
48 #include <sys/param.h>
49 #include <wchar.h>
50 #include <shlib-compat.h>
51
52 #include <rpc/types.h>
53 #include <rpc/xdr.h>
54 #include <rpc/auth.h>
55 #include <rpc/auth_unix.h>
56
57
58 /*
59 * Unix authenticator operations vector
60 */
61 static void authunix_nextverf (AUTH *);
62 static bool_t authunix_marshal (AUTH *, XDR *);
63 static bool_t authunix_validate (AUTH *, struct opaque_auth *);
64 static bool_t authunix_refresh (AUTH *);
65 static void authunix_destroy (AUTH *);
66
67 static const struct auth_ops auth_unix_ops = {
68 authunix_nextverf,
69 authunix_marshal,
70 authunix_validate,
71 authunix_refresh,
72 authunix_destroy
73 };
74
75 /*
76 * This struct is pointed to by the ah_private field of an auth_handle.
77 */
78 struct audata {
79 struct opaque_auth au_origcred; /* original credentials */
80 struct opaque_auth au_shcred; /* short hand cred */
81 u_long au_shfaults; /* short hand cache faults */
82 char au_marshed[MAX_AUTH_BYTES];
83 u_int au_mpos; /* xdr pos at end of marshed */
84 };
85 #define AUTH_PRIVATE(auth) ((struct audata *)auth->ah_private)
86
87 static bool_t marshal_new_auth (AUTH *);
88
89
90 /*
91 * Create a unix style authenticator.
92 * Returns an auth handle with the given stuff in it.
93 */
94 AUTH *
95 authunix_create (char *machname, uid_t uid, gid_t gid, int len,
96 gid_t *aup_gids)
97 {
98 struct authunix_parms aup;
99 char mymem[MAX_AUTH_BYTES];
100 struct timespec now;
101 XDR xdrs;
102 AUTH *auth;
103 struct audata *au;
104
105 /*
106 * Allocate and set up auth handle
107 */
108 auth = (AUTH *) mem_alloc (sizeof (*auth));
109 au = (struct audata *) mem_alloc (sizeof (*au));
110 if (auth == NULL || au == NULL)
111 {
112 no_memory:
113 (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
114 mem_free (auth, sizeof (*auth));
115 mem_free (au, sizeof (*au));
116 return NULL;
117 }
118 auth->ah_ops = (struct auth_ops *) &auth_unix_ops;
119 auth->ah_private = (caddr_t) au;
120 auth->ah_verf = au->au_shcred = _null_auth;
121 au->au_shfaults = 0;
122
123 /*
124 * fill in param struct from the given params
125 */
126 __clock_gettime (CLOCK_REALTIME, &now);
127 aup.aup_time = now.tv_sec;
128 aup.aup_machname = machname;
129 aup.aup_uid = uid;
130 aup.aup_gid = gid;
131 aup.aup_len = (u_int) len;
132 aup.aup_gids = aup_gids;
133
134 /*
135 * Serialize the parameters into origcred
136 */
137 xdrmem_create (&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE);
138 if (!xdr_authunix_parms (&xdrs, &aup))
139 abort ();
140 au->au_origcred.oa_length = len = XDR_GETPOS (&xdrs);
141 au->au_origcred.oa_flavor = AUTH_UNIX;
142 au->au_origcred.oa_base = mem_alloc ((u_int) len);
143 if (au->au_origcred.oa_base == NULL)
144 goto no_memory;
145 memcpy(au->au_origcred.oa_base, mymem, (u_int) len);
146
147 /*
148 * set auth handle to reflect new cred.
149 */
150 auth->ah_cred = au->au_origcred;
151 marshal_new_auth (auth);
152 return auth;
153 }
154 libc_hidden_nolink_sunrpc (authunix_create, GLIBC_2_0)
155
156 /*
157 * Returns an auth handle with parameters determined by doing lots of
158 * syscalls.
159 */
160 AUTH *
161 authunix_create_default (void)
162 {
163 char machname[MAX_MACHINE_NAME + 1];
164
165 if (__gethostname (machname, MAX_MACHINE_NAME) == -1)
166 abort ();
167 machname[MAX_MACHINE_NAME] = 0;
168 uid_t uid = __geteuid ();
169 gid_t gid = __getegid ();
170
171 int max_nr_groups;
172 /* When we have to try a second time, do not use alloca() again. We
173 might have reached the stack limit already. */
174 bool retry = false;
175 again:
176 /* Ask the kernel how many groups there are exactly. Note that we
177 might have to redo all this if the number of groups has changed
178 between the two calls. */
179 max_nr_groups = __getgroups (0, NULL);
180
181 /* Just some random reasonable stack limit. */
182 #define ALLOCA_LIMIT (1024 / sizeof (gid_t))
183 gid_t *gids = NULL;
184 if (max_nr_groups < ALLOCA_LIMIT && ! retry)
185 gids = (gid_t *) alloca (max_nr_groups * sizeof (gid_t));
186 else
187 {
188 gids = (gid_t *) malloc (max_nr_groups * sizeof (gid_t));
189 if (gids == NULL)
190 return NULL;
191 }
192
193 int len = __getgroups (max_nr_groups, gids);
194 if (len == -1)
195 {
196 if (errno == EINVAL)
197 {
198 /* New groups added in the meantime. Try again. */
199 if (max_nr_groups >= ALLOCA_LIMIT || retry)
200 free (gids);
201 retry = true;
202 goto again;
203 }
204 /* No other error can happen. */
205 abort ();
206 }
207
208 /* This braindamaged Sun code forces us here to truncate the
209 list of groups to NGRPS members since the code in
210 authuxprot.c transforms a fixed array. Grrr. */
211 AUTH *result = authunix_create (machname, uid, gid, MIN (NGRPS, len), gids);
212
213 if (max_nr_groups >= ALLOCA_LIMIT || retry)
214 free (gids);
215
216 return result;
217 }
218 #ifdef EXPORT_RPC_SYMBOLS
219 libc_hidden_def (authunix_create_default)
220 #else
221 libc_hidden_nolink_sunrpc (authunix_create_default, GLIBC_2_0)
222 #endif
223
224 /*
225 * authunix operations
226 */
227
228 static void
229 authunix_nextverf (AUTH *auth)
230 {
231 /* no action necessary */
232 }
233
234 static bool_t
235 authunix_marshal (AUTH *auth, XDR *xdrs)
236 {
237 struct audata *au = AUTH_PRIVATE (auth);
238
239 return XDR_PUTBYTES (xdrs, au->au_marshed, au->au_mpos);
240 }
241
242 static bool_t
243 authunix_validate (AUTH *auth, struct opaque_auth *verf)
244 {
245 struct audata *au;
246 XDR xdrs;
247
248 if (verf->oa_flavor == AUTH_SHORT)
249 {
250 au = AUTH_PRIVATE (auth);
251 xdrmem_create (&xdrs, verf->oa_base, verf->oa_length, XDR_DECODE);
252
253 if (au->au_shcred.oa_base != NULL)
254 {
255 mem_free (au->au_shcred.oa_base,
256 au->au_shcred.oa_length);
257 au->au_shcred.oa_base = NULL;
258 }
259 if (xdr_opaque_auth (&xdrs, &au->au_shcred))
260 {
261 auth->ah_cred = au->au_shcred;
262 }
263 else
264 {
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
275 static bool_t
276 authunix_refresh (AUTH *auth)
277 {
278 struct audata *au = AUTH_PRIVATE (auth);
279 struct authunix_parms aup;
280 struct timespec now;
281 XDR xdrs;
282 int stat;
283
284 if (auth->ah_cred.oa_base == au->au_origcred.oa_base)
285 {
286 /* there is no hope. Punt */
287 return FALSE;
288 }
289 au->au_shfaults++;
290
291 /* first deserialize the creds back into a struct authunix_parms */
292 aup.aup_machname = NULL;
293 aup.aup_gids = (gid_t *) NULL;
294 xdrmem_create (&xdrs, au->au_origcred.oa_base,
295 au->au_origcred.oa_length, XDR_DECODE);
296 stat = xdr_authunix_parms (&xdrs, &aup);
297 if (!stat)
298 goto done;
299
300 /* update the time and serialize in place */
301 __clock_gettime (CLOCK_REALTIME, &now);
302 aup.aup_time = now.tv_sec;
303 xdrs.x_op = XDR_ENCODE;
304 XDR_SETPOS (&xdrs, 0);
305 stat = xdr_authunix_parms (&xdrs, &aup);
306 if (!stat)
307 goto done;
308 auth->ah_cred = au->au_origcred;
309 marshal_new_auth (auth);
310 done:
311 /* free the struct authunix_parms created by deserializing */
312 xdrs.x_op = XDR_FREE;
313 (void) xdr_authunix_parms (&xdrs, &aup);
314 XDR_DESTROY (&xdrs);
315 return stat;
316 }
317
318 static void
319 authunix_destroy (AUTH *auth)
320 {
321 struct audata *au = AUTH_PRIVATE (auth);
322
323 mem_free (au->au_origcred.oa_base, au->au_origcred.oa_length);
324
325 if (au->au_shcred.oa_base != NULL)
326 mem_free (au->au_shcred.oa_base, au->au_shcred.oa_length);
327
328 mem_free (auth->ah_private, sizeof (struct audata));
329
330 if (auth->ah_verf.oa_base != NULL)
331 mem_free (auth->ah_verf.oa_base, auth->ah_verf.oa_length);
332
333 mem_free ((caddr_t) auth, sizeof (*auth));
334 }
335
336 /*
337 * Marshals (pre-serializes) an auth struct.
338 * sets private data, au_marshed and au_mpos
339 */
340 static bool_t
341 marshal_new_auth (AUTH *auth)
342 {
343 XDR xdr_stream;
344 XDR *xdrs = &xdr_stream;
345 struct audata *au = AUTH_PRIVATE (auth);
346
347 xdrmem_create (xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
348 if ((!xdr_opaque_auth (xdrs, &(auth->ah_cred))) ||
349 (!xdr_opaque_auth (xdrs, &(auth->ah_verf))))
350 perror (_("auth_unix.c: Fatal marshalling problem"));
351 else
352 au->au_mpos = XDR_GETPOS (xdrs);
353
354 XDR_DESTROY (xdrs);
355
356 return TRUE;
357 }