1
2 /*
3 * Copyright (c) 1988 by Sun Microsystems, Inc.
4 *
5 * @(#)svcauth_des.c 2.3 89/07/11 4.0 RPCSRC; from 1.15 88/02/08 SMI
6 * $FreeBSD: src/lib/libc/rpc/svc_auth_des.c,v 1.9 2002/03/22 23:18:37 obrien Exp $
7 */
8
9 /*-
10 * Copyright (c) 2009, Sun Microsystems, Inc.
11 * All rights reserved.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions are met:
15 * - Redistributions of source code must retain the above copyright notice,
16 * this list of conditions and the following disclaimer.
17 * - Redistributions in binary form must reproduce the above copyright notice,
18 * this list of conditions and the following disclaimer in the documentation
19 * and/or other materials provided with the distribution.
20 * - Neither the name of Sun Microsystems, Inc. nor the names of its
21 * contributors may be used to endorse or promote products derived
22 * from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37 /*
38 * svcauth_des.c, server-side des authentication
39 *
40 * We insure for the service the following:
41 * (1) The timestamp microseconds do not exceed 1 million.
42 * (2) The timestamp plus the window is less than the current time.
43 * (3) The timestamp is not less than the one previously
44 * seen in the current session.
45 *
46 * It is up to the server to determine if the window size is
47 * too small .
48 *
49 */
50
51 #include "namespace.h"
52 #include "reentrant.h"
53 #include <string.h>
54 #include <stdlib.h>
55 #include <stdio.h>
56 #include <unistd.h>
57 #include <rpc/des_crypt.h>
58 #include <sys/param.h>
59 #include <netinet/in.h>
60 #include <rpc/types.h>
61 #include <rpc/xdr.h>
62 #include <rpc/auth.h>
63 #include <rpc/auth_des.h>
64 #include <rpc/svc.h>
65 #include <rpc/rpc_msg.h>
66 #include <rpc/svc_auth.h>
67 #include "un-namespace.h"
68
69 #include "libc_private.h"
70
71 extern int key_decryptsession_pk(const char *, netobj *, des_block *);
72
73 #define debug(msg) printf("svcauth_des: %s\n", msg)
74
75 #define USEC_PER_SEC ((u_long) 1000000L)
76 #define BEFORE(t1, t2) timercmp(t1, t2, <)
77
78 /*
79 * LRU cache of conversation keys and some other useful items.
80 */
81 #define AUTHDES_CACHESZ 64
82 struct cache_entry {
83 des_block key; /* conversation key */
84 char *rname; /* client's name */
85 u_int window; /* credential lifetime window */
86 struct timeval laststamp; /* detect replays of creds */
87 char *localcred; /* generic local credential */
88 };
89 static struct cache_entry *authdes_cache/* [AUTHDES_CACHESZ] */;
90 static short *authdes_lru/* [AUTHDES_CACHESZ] */;
91
92 static void cache_init(void); /* initialize the cache */
93 static short cache_spot(des_block *, char *, struct timeval *);
94 /* find an entry in the cache */
95 static void cache_ref(short sid); /* note that sid was ref'd */
96
97 static void invalidate(char *); /* invalidate entry in cache */
98
99 /*
100 * cache statistics
101 */
102 static struct {
103 u_long ncachehits; /* times cache hit, and is not replay */
104 u_long ncachereplays; /* times cache hit, and is replay */
105 u_long ncachemisses; /* times cache missed */
106 } svcauthdes_stats;
107
108 /*
109 * Service side authenticator for AUTH_DES
110 */
111 enum auth_stat
_svcauth_des(struct svc_req * rqst,struct rpc_msg * msg)112 _svcauth_des(struct svc_req *rqst, struct rpc_msg *msg)
113 {
114
115 long *ixdr;
116 des_block cryptbuf[2];
117 struct authdes_cred *cred;
118 struct authdes_verf verf;
119 int status;
120 struct cache_entry *entry;
121 short sid = 0;
122 des_block *sessionkey;
123 des_block ivec;
124 u_int window;
125 struct timeval timestamp;
126 u_long namelen;
127 struct area {
128 struct authdes_cred area_cred;
129 char area_netname[MAXNETNAMELEN+1];
130 } *area;
131
132 if (authdes_cache == NULL) {
133 cache_init();
134 }
135
136 area = (struct area *)rqst->rq_clntcred;
137 cred = (struct authdes_cred *)&area->area_cred;
138
139 /*
140 * Get the credential
141 */
142 ixdr = (long *)msg->rm_call.cb_cred.oa_base;
143 cred->adc_namekind = IXDR_GET_ENUM(ixdr, enum authdes_namekind);
144 switch (cred->adc_namekind) {
145 case ADN_FULLNAME:
146 namelen = IXDR_GET_U_LONG(ixdr);
147 if (namelen > MAXNETNAMELEN) {
148 return (AUTH_BADCRED);
149 }
150 cred->adc_fullname.name = area->area_netname;
151 bcopy((char *)ixdr, cred->adc_fullname.name,
152 (u_int)namelen);
153 cred->adc_fullname.name[namelen] = 0;
154 ixdr += (RNDUP(namelen) / BYTES_PER_XDR_UNIT);
155 cred->adc_fullname.key.key.high = (u_long)*ixdr++;
156 cred->adc_fullname.key.key.low = (u_long)*ixdr++;
157 cred->adc_fullname.window = (u_long)*ixdr++;
158 break;
159 case ADN_NICKNAME:
160 cred->adc_nickname = (u_long)*ixdr++;
161 break;
162 default:
163 return (AUTH_BADCRED);
164 }
165
166 /*
167 * Get the verifier
168 */
169 ixdr = (long *)msg->rm_call.cb_verf.oa_base;
170 verf.adv_xtimestamp.key.high = (u_long)*ixdr++;
171 verf.adv_xtimestamp.key.low = (u_long)*ixdr++;
172 verf.adv_int_u = (u_long)*ixdr++;
173
174
175 /*
176 * Get the conversation key
177 */
178 if (cred->adc_namekind == ADN_FULLNAME) {
179 netobj pkey;
180 char pkey_data[1024];
181
182 sessionkey = &cred->adc_fullname.key;
183 if (! getpublickey(cred->adc_fullname.name, pkey_data)) {
184 debug("getpublickey");
185 return(AUTH_BADCRED);
186 }
187 pkey.n_bytes = pkey_data;
188 pkey.n_len = strlen(pkey_data) + 1;
189 if (key_decryptsession_pk(cred->adc_fullname.name, &pkey,
190 sessionkey) < 0) {
191 debug("decryptsessionkey");
192 return (AUTH_BADCRED); /* key not found */
193 }
194 } else { /* ADN_NICKNAME */
195 sid = (short)cred->adc_nickname;
196 if (sid < 0 || sid >= AUTHDES_CACHESZ) {
197 debug("bad nickname");
198 return (AUTH_BADCRED); /* garbled credential */
199 }
200 sessionkey = &authdes_cache[sid].key;
201 }
202
203
204 /*
205 * Decrypt the timestamp
206 */
207 cryptbuf[0] = verf.adv_xtimestamp;
208 if (cred->adc_namekind == ADN_FULLNAME) {
209 cryptbuf[1].key.high = cred->adc_fullname.window;
210 cryptbuf[1].key.low = verf.adv_winverf;
211 ivec.key.high = ivec.key.low = 0;
212 status = cbc_crypt((char *)sessionkey, (char *)cryptbuf,
213 2*sizeof(des_block), DES_DECRYPT | DES_HW,
214 (char *)&ivec);
215 } else {
216 status = ecb_crypt((char *)sessionkey, (char *)cryptbuf,
217 sizeof(des_block), DES_DECRYPT | DES_HW);
218 }
219 if (DES_FAILED(status)) {
220 debug("decryption failure");
221 return (AUTH_FAILED); /* system error */
222 }
223
224 /*
225 * XDR the decrypted timestamp
226 */
227 ixdr = (long *)cryptbuf;
228 timestamp.tv_sec = IXDR_GET_LONG(ixdr);
229 timestamp.tv_usec = IXDR_GET_LONG(ixdr);
230
231 /*
232 * Check for valid credentials and verifiers.
233 * They could be invalid because the key was flushed
234 * out of the cache, and so a new session should begin.
235 * Be sure and send AUTH_REJECTED{CRED, VERF} if this is the case.
236 */
237 {
238 struct timeval current;
239 int nick;
240 int winverf;
241
242 if (cred->adc_namekind == ADN_FULLNAME) {
243 window = IXDR_GET_U_LONG(ixdr);
244 winverf = IXDR_GET_U_LONG(ixdr);
245 if (winverf != window - 1) {
246 debug("window verifier mismatch");
247 return (AUTH_BADCRED); /* garbled credential */
248 }
249 sid = cache_spot(sessionkey, cred->adc_fullname.name,
250 ×tamp);
251 if (sid < 0) {
252 debug("replayed credential");
253 return (AUTH_REJECTEDCRED); /* replay */
254 }
255 nick = 0;
256 } else { /* ADN_NICKNAME */
257 window = authdes_cache[sid].window;
258 nick = 1;
259 }
260
261 if ((u_long)timestamp.tv_usec >= USEC_PER_SEC) {
262 debug("invalid usecs");
263 /* cached out (bad key), or garbled verifier */
264 return (nick ? AUTH_REJECTEDVERF : AUTH_BADVERF);
265 }
266 if (nick && BEFORE(×tamp,
267 &authdes_cache[sid].laststamp)) {
268 debug("timestamp before last seen");
269 return (AUTH_REJECTEDVERF); /* replay */
270 }
271 gettimeofday(¤t, NULL);
272 current.tv_sec -= window; /* allow for expiration */
273 if (!BEFORE(¤t, ×tamp)) {
274 debug("timestamp expired");
275 /* replay, or garbled credential */
276 return (nick ? AUTH_REJECTEDVERF : AUTH_BADCRED);
277 }
278 }
279
280 /*
281 * Set up the reply verifier
282 */
283 verf.adv_nickname = (u_long)sid;
284
285 /*
286 * xdr the timestamp before encrypting
287 */
288 ixdr = (long *)cryptbuf;
289 IXDR_PUT_LONG(ixdr, timestamp.tv_sec - 1);
290 IXDR_PUT_LONG(ixdr, timestamp.tv_usec);
291
292 /*
293 * encrypt the timestamp
294 */
295 status = ecb_crypt((char *)sessionkey, (char *)cryptbuf,
296 sizeof(des_block), DES_ENCRYPT | DES_HW);
297 if (DES_FAILED(status)) {
298 debug("encryption failure");
299 return (AUTH_FAILED); /* system error */
300 }
301 verf.adv_xtimestamp = cryptbuf[0];
302
303 /*
304 * Serialize the reply verifier, and update rqst
305 */
306 ixdr = (long *)msg->rm_call.cb_verf.oa_base;
307 *ixdr++ = (long)verf.adv_xtimestamp.key.high;
308 *ixdr++ = (long)verf.adv_xtimestamp.key.low;
309 *ixdr++ = (long)verf.adv_int_u;
310
311 rqst->rq_xprt->xp_verf.oa_flavor = AUTH_DES;
312 rqst->rq_xprt->xp_verf.oa_base = msg->rm_call.cb_verf.oa_base;
313 rqst->rq_xprt->xp_verf.oa_length =
314 (char *)ixdr - msg->rm_call.cb_verf.oa_base;
315
316 /*
317 * We succeeded, commit the data to the cache now and
318 * finish cooking the credential.
319 */
320 entry = &authdes_cache[sid];
321 entry->laststamp = timestamp;
322 cache_ref(sid);
323 if (cred->adc_namekind == ADN_FULLNAME) {
324 cred->adc_fullname.window = window;
325 cred->adc_nickname = (u_long)sid; /* save nickname */
326 if (entry->rname != NULL) {
327 mem_free(entry->rname, strlen(entry->rname) + 1);
328 }
329 entry->rname = (char *)mem_alloc((u_int)strlen(cred->adc_fullname.name)
330 + 1);
331 if (entry->rname != NULL) {
332 strcpy(entry->rname, cred->adc_fullname.name);
333 } else {
334 debug("out of memory");
335 }
336 entry->key = *sessionkey;
337 entry->window = window;
338 invalidate(entry->localcred); /* mark any cached cred invalid */
339 } else { /* ADN_NICKNAME */
340 /*
341 * nicknames are cooked into fullnames
342 */
343 cred->adc_namekind = ADN_FULLNAME;
344 cred->adc_fullname.name = entry->rname;
345 cred->adc_fullname.key = entry->key;
346 cred->adc_fullname.window = entry->window;
347 }
348 return (AUTH_OK); /* we made it!*/
349 }
350
351
352 /*
353 * Initialize the cache
354 */
355 static void
cache_init(void)356 cache_init(void)
357 {
358 int i;
359
360 authdes_cache = (struct cache_entry *)
361 mem_alloc(sizeof(struct cache_entry) * AUTHDES_CACHESZ);
362 bzero((char *)authdes_cache,
363 sizeof(struct cache_entry) * AUTHDES_CACHESZ);
364
365 authdes_lru = (short *)mem_alloc(sizeof(short) * AUTHDES_CACHESZ);
366 /*
367 * Initialize the lru list
368 */
369 for (i = 0; i < AUTHDES_CACHESZ; i++) {
370 authdes_lru[i] = i;
371 }
372 }
373
374
375 /*
376 * Find the lru victim
377 */
378 static short
cache_victim(void)379 cache_victim(void)
380 {
381 return (authdes_lru[AUTHDES_CACHESZ-1]);
382 }
383
384 /*
385 * Note that sid was referenced
386 */
387 static void
cache_ref(short sid)388 cache_ref(short sid)
389 {
390 int i;
391 short curr;
392 short prev;
393
394 prev = authdes_lru[0];
395 authdes_lru[0] = sid;
396 for (i = 1; prev != sid; i++) {
397 curr = authdes_lru[i];
398 authdes_lru[i] = prev;
399 prev = curr;
400 }
401 }
402
403
404 /*
405 * Find a spot in the cache for a credential containing
406 * the items given. Return -1 if a replay is detected, otherwise
407 * return the spot in the cache.
408 */
409 static short
cache_spot(des_block * key,char * name,struct timeval * timestamp)410 cache_spot(des_block *key, char *name, struct timeval *timestamp)
411 {
412 struct cache_entry *cp;
413 int i;
414 u_long hi;
415
416 hi = key->key.high;
417 for (cp = authdes_cache, i = 0; i < AUTHDES_CACHESZ; i++, cp++) {
418 if (cp->key.key.high == hi &&
419 cp->key.key.low == key->key.low &&
420 cp->rname != NULL &&
421 bcmp(cp->rname, name, strlen(name) + 1) == 0) {
422 if (BEFORE(timestamp, &cp->laststamp)) {
423 svcauthdes_stats.ncachereplays++;
424 return (-1); /* replay */
425 }
426 svcauthdes_stats.ncachehits++;
427 return (i); /* refresh */
428 }
429 }
430 svcauthdes_stats.ncachemisses++;
431 return (cache_victim()); /* new credential */
432 }
433
434
435 #if defined(sun) || defined(vax) || \
436 defined(__FreeBSD__) || defined(__DragonFly__)
437 /*
438 * Local credential handling stuff.
439 * NOTE: bsd unix dependent.
440 * Other operating systems should put something else here.
441 */
442 #define UNKNOWN -2 /* grouplen, if cached cred is unknown user */
443 #define INVALID -1 /* grouplen, if cache entry is invalid */
444
445 struct bsdcred {
446 short uid; /* cached uid */
447 short gid; /* cached gid */
448 short grouplen; /* length of cached groups */
449 short groups[NGROUPS]; /* cached groups */
450 };
451
452 /*
453 * Map a des credential into a unix cred.
454 * We cache the credential here so the application does
455 * not have to make an rpc call every time to interpret
456 * the credential.
457 */
458 int
authdes_getucred(struct authdes_cred * adc,uid_t * uid,gid_t * gid,int * grouplen,gid_t * groups)459 authdes_getucred(struct authdes_cred *adc, uid_t *uid, gid_t *gid,
460 int *grouplen, gid_t *groups)
461 {
462 unsigned sid;
463 int i;
464 uid_t i_uid;
465 gid_t i_gid;
466 int i_grouplen;
467 struct bsdcred *cred;
468
469 sid = adc->adc_nickname;
470 if (sid >= AUTHDES_CACHESZ) {
471 debug("invalid nickname");
472 return (0);
473 }
474 cred = (struct bsdcred *)authdes_cache[sid].localcred;
475 if (cred == NULL) {
476 cred = (struct bsdcred *)mem_alloc(sizeof(struct bsdcred));
477 authdes_cache[sid].localcred = (char *)cred;
478 cred->grouplen = INVALID;
479 }
480 if (cred->grouplen == INVALID) {
481 /*
482 * not in cache: lookup
483 */
484 if (!netname2user(adc->adc_fullname.name, &i_uid, &i_gid,
485 &i_grouplen, groups))
486 {
487 debug("unknown netname");
488 cred->grouplen = UNKNOWN; /* mark as lookup up, but not found */
489 return (0);
490 }
491 debug("missed ucred cache");
492 *uid = cred->uid = i_uid;
493 *gid = cred->gid = i_gid;
494 *grouplen = cred->grouplen = i_grouplen;
495 for (i = i_grouplen - 1; i >= 0; i--) {
496 cred->groups[i] = groups[i]; /* int to short */
497 }
498 return (1);
499 } else if (cred->grouplen == UNKNOWN) {
500 /*
501 * Already lookup up, but no match found
502 */
503 return (0);
504 }
505
506 /*
507 * cached credentials
508 */
509 *uid = cred->uid;
510 *gid = cred->gid;
511 *grouplen = cred->grouplen;
512 for (i = cred->grouplen - 1; i >= 0; i--) {
513 groups[i] = cred->groups[i]; /* short to int */
514 }
515 return (1);
516 }
517
518 static void
invalidate(char * cred)519 invalidate(char *cred)
520 {
521 if (cred == NULL) {
522 return;
523 }
524 ((struct bsdcred *)cred)->grouplen = INVALID;
525 }
526 #endif
527
528