Remove some unnecessary inclusions of <sys/cdefs.h> across the tree.
[dragonfly.git] / lib / libc / rpc / auth_des.c
1 /*
2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3  * unrestricted use provided that this legend is included on all tape
4  * media and as a part of the software program in whole or part.  Users
5  * may copy or modify Sun RPC without charge, but are not authorized
6  * to license or distribute it to anyone else except as part of a product or
7  * program developed by the user.
8  * 
9  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
10  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
11  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
12  * 
13  * Sun RPC is provided with no support and without any obligation on the
14  * part of Sun Microsystems, Inc. to assist in its use, correction,
15  * modification or enhancement.
16  * 
17  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
18  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
19  * OR ANY PART THEREOF.
20  * 
21  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
22  * or profits or other special, indirect and consequential damages, even if
23  * Sun has been advised of the possibility of such damages.
24  * 
25  * Sun Microsystems, Inc.
26  * 2550 Garcia Avenue
27  * Mountain View, California  94043
28  *
29  * @(#)auth_des.c       2.2 88/07/29 4.0 RPCSRC; from 1.9 88/02/08 SMI
30  * $FreeBSD: src/lib/libc/rpc/auth_des.c,v 1.10 2006/02/27 22:10:58 deischen Exp $
31  */
32 /*
33  * Copyright (c) 1988 by Sun Microsystems, Inc.
34  */
35 /*
36  * auth_des.c, client-side implementation of DES authentication
37  */
38
39 #include "namespace.h"
40 #include "reentrant.h"
41 #include <err.h>
42 #include <errno.h>
43 #include <string.h>
44 #include <stdlib.h>
45 #include <unistd.h>
46 #include <rpc/des_crypt.h>
47 #include <syslog.h>
48 #include <rpc/types.h>
49 #include <rpc/auth.h>
50 #include <rpc/auth_des.h>
51 #include <rpc/clnt.h>
52 #include <rpc/xdr.h>
53 #include <sys/socket.h>
54 #undef NIS
55 #include <rpcsvc/nis.h>
56 #include "un-namespace.h"
57 #include "mt_misc.h"
58
59 #define USEC_PER_SEC            1000000
60 #define RTIME_TIMEOUT           5       /* seconds to wait for sync */
61
62 #define AUTH_PRIVATE(auth)      (struct ad_private *) auth->ah_private
63 #define ALLOC(object_type)      (object_type *) mem_alloc(sizeof(object_type))
64 #define FREE(ptr, size)         mem_free((char *)(ptr), (int) size)
65 #define ATTEMPT(xdr_op)         if (!(xdr_op)) return (FALSE)
66
67 extern bool_t   xdr_authdes_cred(XDR *, struct authdes_cred *);
68 extern bool_t   xdr_authdes_verf(XDR *, struct authdes_verf *);
69 extern int      key_encryptsession_pk(char *, netobj *, des_block *);
70
71 extern bool_t   __rpc_get_time_offset(struct timeval *, nis_server *, char *,
72                                       char **, char **);
73
74
75 /* 
76  * DES authenticator operations vector
77  */
78 static void     authdes_nextverf(AUTH *);
79 static bool_t   authdes_marshal(AUTH *, XDR *);
80 static bool_t   authdes_validate(AUTH *, struct opaque_auth *);
81 static bool_t   authdes_refresh(AUTH *, void *);
82 static void     authdes_destroy(AUTH *);
83
84 static struct auth_ops *authdes_ops(void);
85
86 /*
87  * This struct is pointed to by the ah_private field of an "AUTH *"
88  */
89 struct ad_private {
90         char *ad_fullname;              /* client's full name */
91         u_int ad_fullnamelen;           /* length of name, rounded up */
92         char *ad_servername;            /* server's full name */
93         u_int ad_servernamelen;         /* length of name, rounded up */
94         u_int ad_window;                /* client specified window */
95         bool_t ad_dosync;               /* synchronize? */
96         struct netbuf ad_syncaddr;      /* remote host to synch with */
97         char *ad_timehost;              /* remote host to synch with */
98         struct timeval ad_timediff;     /* server's time - client's time */
99         u_int ad_nickname;              /* server's nickname for client */
100         struct authdes_cred ad_cred;    /* storage for credential */
101         struct authdes_verf ad_verf;    /* storage for verifier */
102         struct timeval ad_timestamp;    /* timestamp sent */
103         des_block ad_xkey;              /* encrypted conversation key */
104         u_char ad_pkey[1024];           /* Server's actual public key */
105         char *ad_netid;                 /* Timehost netid */
106         char *ad_uaddr;                 /* Timehost uaddr */
107         nis_server *ad_nis_srvr;        /* NIS+ server struct */
108 };
109
110 AUTH *authdes_pk_seccreate(const char *, netobj *, u_int, const char *,
111                            const des_block *, nis_server *);
112 /*
113  * documented version of authdes_seccreate
114  */
115 /*
116         servername:     network name of server
117         win:            time to live
118         timehost:       optional hostname to sync with
119         ckey:           optional conversation key to use
120 */
121
122 AUTH *
123 authdes_seccreate(const char *servername, const u_int win,
124                   const char *timehost, const des_block *ckey)
125 {
126         u_char  pkey_data[1024];
127         netobj  pkey;
128         AUTH    *dummy;
129
130         if (! getpublickey(servername, (char *) pkey_data)) {
131                 syslog(LOG_ERR,
132                     "authdes_seccreate: no public key found for %s",
133                     servername);
134                 return (NULL);
135         }
136
137         pkey.n_bytes = (char *) pkey_data;
138         pkey.n_len = (u_int)strlen((char *)pkey_data) + 1;
139         dummy = authdes_pk_seccreate(servername, &pkey, win, timehost,
140             ckey, NULL);
141         return (dummy);
142 }
143
144 /*
145  * Slightly modified version of authdessec_create which takes the public key
146  * of the server principal as an argument. This spares us a call to
147  * getpublickey() which in the nameserver context can cause a deadlock.
148  */
149 AUTH *
150 authdes_pk_seccreate(const char *servername, netobj *pkey, u_int window,
151                      const char *timehost, const des_block *ckey,
152                      nis_server *srvr)
153 {
154         AUTH *auth;
155         struct ad_private *ad;
156         char namebuf[MAXNETNAMELEN+1];
157
158         /*
159          * Allocate everything now
160          */
161         auth = ALLOC(AUTH);
162         if (auth == NULL) {
163                 syslog(LOG_ERR, "authdes_pk_seccreate: out of memory");
164                 return (NULL);
165         }
166         ad = ALLOC(struct ad_private);
167         if (ad == NULL) {
168                 syslog(LOG_ERR, "authdes_pk_seccreate: out of memory");
169                 goto failed;
170         }
171         ad->ad_fullname = ad->ad_servername = NULL; /* Sanity reasons */
172         ad->ad_timehost = NULL;
173         ad->ad_netid = NULL;
174         ad->ad_uaddr = NULL;
175         ad->ad_nis_srvr = NULL;
176         ad->ad_timediff.tv_sec = 0;
177         ad->ad_timediff.tv_usec = 0;
178         memcpy(ad->ad_pkey, pkey->n_bytes, pkey->n_len);
179         if (!getnetname(namebuf))
180                 goto failed;
181         ad->ad_fullnamelen = RNDUP((u_int) strlen(namebuf));
182         ad->ad_fullname = (char *)mem_alloc(ad->ad_fullnamelen + 1);
183         ad->ad_servernamelen = strlen(servername);
184         ad->ad_servername = (char *)mem_alloc(ad->ad_servernamelen + 1);
185
186         if (ad->ad_fullname == NULL || ad->ad_servername == NULL) {
187                 syslog(LOG_ERR, "authdes_seccreate: out of memory");
188                 goto failed;
189         }
190         if (timehost != NULL) {
191                 ad->ad_timehost = (char *)mem_alloc(strlen(timehost) + 1);
192                 if (ad->ad_timehost == NULL) {
193                         syslog(LOG_ERR, "authdes_seccreate: out of memory");
194                         goto failed;
195                 }
196                 memcpy(ad->ad_timehost, timehost, strlen(timehost) + 1);
197                 ad->ad_dosync = TRUE;
198         } else if (srvr != NULL) {
199                 ad->ad_nis_srvr = srvr; /* transient */
200                 ad->ad_dosync = TRUE;
201         } else {
202                 ad->ad_dosync = FALSE;
203         }
204         memcpy(ad->ad_fullname, namebuf, ad->ad_fullnamelen + 1);
205         memcpy(ad->ad_servername, servername, ad->ad_servernamelen + 1);
206         ad->ad_window = window;
207         if (ckey == NULL) {
208                 if (key_gendes(&auth->ah_key) < 0) {
209                         syslog(LOG_ERR,
210             "authdes_seccreate: keyserv(1m) is unable to generate session key");
211                         goto failed;
212                 }
213         } else {
214                 auth->ah_key = *ckey;
215         }
216
217         /*
218          * Set up auth handle
219          */
220         auth->ah_cred.oa_flavor = AUTH_DES;
221         auth->ah_verf.oa_flavor = AUTH_DES;
222         auth->ah_ops = authdes_ops();
223         auth->ah_private = (caddr_t)ad;
224
225         if (!authdes_refresh(auth, NULL)) {
226                 goto failed;
227         }
228         ad->ad_nis_srvr = NULL; /* not needed any longer */
229         return (auth);
230
231 failed:
232         if (auth)
233                 FREE(auth, sizeof (AUTH));
234         if (ad) {
235                 if (ad->ad_fullname)
236                         FREE(ad->ad_fullname, ad->ad_fullnamelen + 1);
237                 if (ad->ad_servername)
238                         FREE(ad->ad_servername, ad->ad_servernamelen + 1);
239                 if (ad->ad_timehost)
240                         FREE(ad->ad_timehost, strlen(ad->ad_timehost) + 1);
241                 if (ad->ad_netid)
242                         FREE(ad->ad_netid, strlen(ad->ad_netid) + 1);
243                 if (ad->ad_uaddr)
244                         FREE(ad->ad_uaddr, strlen(ad->ad_uaddr) + 1);
245                 FREE(ad, sizeof (struct ad_private));
246         }
247         return (NULL);
248 }
249
250 /*
251  * Implement the five authentication operations
252  */
253
254
255 /*
256  * 1. Next Verifier
257  */     
258 /*ARGSUSED*/
259 static void
260 authdes_nextverf(AUTH *auth)
261 {
262         /* what the heck am I supposed to do??? */
263 }
264
265
266 /*
267  * 2. Marshal
268  */
269 static bool_t
270 authdes_marshal(AUTH *auth, XDR *xdrs)
271 {
272 /* LINTED pointer alignment */
273         struct ad_private *ad = AUTH_PRIVATE(auth);
274         struct authdes_cred *cred = &ad->ad_cred;
275         struct authdes_verf *verf = &ad->ad_verf;
276         des_block cryptbuf[2];
277         des_block ivec;
278         int status;
279         int len;
280         rpc_inline_t *ixdr;
281
282         /*
283          * Figure out the "time", accounting for any time difference
284          * with the server if necessary.
285          */
286         gettimeofday(&ad->ad_timestamp, NULL);
287         ad->ad_timestamp.tv_sec += ad->ad_timediff.tv_sec;
288         ad->ad_timestamp.tv_usec += ad->ad_timediff.tv_usec;
289         while (ad->ad_timestamp.tv_usec >= USEC_PER_SEC) {
290                 ad->ad_timestamp.tv_usec -= USEC_PER_SEC;
291                 ad->ad_timestamp.tv_sec++;
292         }
293
294         /*
295          * XDR the timestamp and possibly some other things, then
296          * encrypt them.
297          */
298         ixdr = (rpc_inline_t *)cryptbuf;
299         IXDR_PUT_INT32(ixdr, ad->ad_timestamp.tv_sec);
300         IXDR_PUT_INT32(ixdr, ad->ad_timestamp.tv_usec);
301         if (ad->ad_cred.adc_namekind == ADN_FULLNAME) {
302                 IXDR_PUT_U_INT32(ixdr, ad->ad_window);
303                 IXDR_PUT_U_INT32(ixdr, ad->ad_window - 1);
304                 ivec.key.high = ivec.key.low = 0;       
305                 status = cbc_crypt((char *)&auth->ah_key, (char *)cryptbuf, 
306                         (u_int) 2 * sizeof (des_block),
307                         DES_ENCRYPT | DES_HW, (char *)&ivec);
308         } else {
309                 status = ecb_crypt((char *)&auth->ah_key, (char *)cryptbuf, 
310                         (u_int) sizeof (des_block),
311                         DES_ENCRYPT | DES_HW);
312         }
313         if (DES_FAILED(status)) {
314                 syslog(LOG_ERR, "authdes_marshal: DES encryption failure");
315                 return (FALSE);
316         }
317         ad->ad_verf.adv_xtimestamp = cryptbuf[0];
318         if (ad->ad_cred.adc_namekind == ADN_FULLNAME) {
319                 ad->ad_cred.adc_fullname.window = cryptbuf[1].key.high;
320                 ad->ad_verf.adv_winverf = cryptbuf[1].key.low;
321         } else {
322                 ad->ad_cred.adc_nickname = ad->ad_nickname;
323                 ad->ad_verf.adv_winverf = 0;
324         }
325
326         /*
327          * Serialize the credential and verifier into opaque
328          * authentication data.
329          */
330         if (ad->ad_cred.adc_namekind == ADN_FULLNAME) {
331                 len = ((1 + 1 + 2 + 1)*BYTES_PER_XDR_UNIT + ad->ad_fullnamelen);
332         } else {
333                 len = (1 + 1)*BYTES_PER_XDR_UNIT;
334         }
335
336         if ((ixdr = xdr_inline(xdrs, 2*BYTES_PER_XDR_UNIT))) {
337                 IXDR_PUT_INT32(ixdr, AUTH_DES);
338                 IXDR_PUT_INT32(ixdr, len);
339         } else {
340                 ATTEMPT(xdr_putint32(xdrs, (int *)&auth->ah_cred.oa_flavor));
341                 ATTEMPT(xdr_putint32(xdrs, &len));
342         }
343         ATTEMPT(xdr_authdes_cred(xdrs, cred));
344
345         len = (2 + 1)*BYTES_PER_XDR_UNIT; 
346         if ((ixdr = xdr_inline(xdrs, 2*BYTES_PER_XDR_UNIT))) {
347                 IXDR_PUT_INT32(ixdr, AUTH_DES);
348                 IXDR_PUT_INT32(ixdr, len);
349         } else {
350                 ATTEMPT(xdr_putint32(xdrs, (int *)&auth->ah_verf.oa_flavor));
351                 ATTEMPT(xdr_putint32(xdrs, &len));
352         }
353         ATTEMPT(xdr_authdes_verf(xdrs, verf));
354         return (TRUE);
355 }
356
357
358 /*
359  * 3. Validate
360  */
361 static bool_t
362 authdes_validate(AUTH *auth, struct opaque_auth *rverf)
363 {
364 /* LINTED pointer alignment */
365         struct ad_private *ad = AUTH_PRIVATE(auth);
366         struct authdes_verf verf;
367         int status;
368         uint32_t *ixdr;
369         des_block buf;
370
371         if (rverf->oa_length != (2 + 1) * BYTES_PER_XDR_UNIT) {
372                 return (FALSE);
373         }
374 /* LINTED pointer alignment */
375         ixdr = (uint32_t *)rverf->oa_base;
376         buf.key.high = (uint32_t)*ixdr++;
377         buf.key.low = (uint32_t)*ixdr++;
378         verf.adv_int_u = (uint32_t)*ixdr++;
379
380         /*
381          * Decrypt the timestamp
382          */
383         status = ecb_crypt((char *)&auth->ah_key, (char *)&buf,
384                 (u_int)sizeof (des_block), DES_DECRYPT | DES_HW);
385
386         if (DES_FAILED(status)) {
387                 syslog(LOG_ERR, "authdes_validate: DES decryption failure");
388                 return (FALSE);
389         }
390
391         /*
392          * xdr the decrypted timestamp
393          */
394 /* LINTED pointer alignment */
395         ixdr = (uint32_t *)buf.c;
396         verf.adv_timestamp.tv_sec = IXDR_GET_INT32(ixdr) + 1;
397         verf.adv_timestamp.tv_usec = IXDR_GET_INT32(ixdr);
398
399         /*
400          * validate
401          */
402         if (bcmp((char *)&ad->ad_timestamp, (char *)&verf.adv_timestamp,
403                  sizeof(struct timeval)) != 0) {
404                 syslog(LOG_DEBUG, "authdes_validate: verifier mismatch");
405                 return (FALSE);
406         }
407
408         /*
409          * We have a nickname now, let's use it
410          */
411         ad->ad_nickname = verf.adv_nickname;
412         ad->ad_cred.adc_namekind = ADN_NICKNAME;
413         return (TRUE);
414 }
415
416 /*
417  * 4. Refresh
418  */
419 /*ARGSUSED*/
420 static bool_t
421 authdes_refresh(AUTH *auth, void *dummy)
422 {
423 /* LINTED pointer alignment */
424         struct ad_private *ad = AUTH_PRIVATE(auth);
425         struct authdes_cred *cred = &ad->ad_cred;
426         int             ok;
427         netobj          pkey;
428
429         if (ad->ad_dosync) {
430                 ok = __rpc_get_time_offset(&ad->ad_timediff, ad->ad_nis_srvr,
431                     ad->ad_timehost, &(ad->ad_uaddr),
432                     &(ad->ad_netid));
433                 if (! ok) {
434                         /*
435                          * Hope the clocks are synced!
436                          */
437                         ad->ad_dosync = 0;
438                         syslog(LOG_DEBUG,
439                             "authdes_refresh: unable to synchronize clock");
440                 }
441         }
442         ad->ad_xkey = auth->ah_key;
443         pkey.n_bytes = (char *)(ad->ad_pkey);
444         pkey.n_len = (u_int)strlen((char *)ad->ad_pkey) + 1;
445         if (key_encryptsession_pk(ad->ad_servername, &pkey, &ad->ad_xkey) < 0) {
446                 syslog(LOG_INFO,
447                     "authdes_refresh: keyserv(1m) is unable to encrypt session key");
448                 return (FALSE);
449         }
450         cred->adc_fullname.key = ad->ad_xkey;
451         cred->adc_namekind = ADN_FULLNAME;
452         cred->adc_fullname.name = ad->ad_fullname;
453         return (TRUE);
454 }
455
456
457 /*
458  * 5. Destroy
459  */
460 static void
461 authdes_destroy(AUTH *auth)
462 {
463 /* LINTED pointer alignment */
464         struct ad_private *ad = AUTH_PRIVATE(auth);
465
466         FREE(ad->ad_fullname, ad->ad_fullnamelen + 1);
467         FREE(ad->ad_servername, ad->ad_servernamelen + 1);
468         if (ad->ad_timehost)
469                 FREE(ad->ad_timehost, strlen(ad->ad_timehost) + 1);
470         if (ad->ad_netid)
471                 FREE(ad->ad_netid, strlen(ad->ad_netid) + 1);
472         if (ad->ad_uaddr)
473                 FREE(ad->ad_uaddr, strlen(ad->ad_uaddr) + 1);
474         FREE(ad, sizeof(struct ad_private));
475         FREE(auth, sizeof(AUTH));
476 }
477
478 static struct auth_ops *
479 authdes_ops(void)
480 {
481         static struct auth_ops ops;
482
483         /* VARIABLES PROTECTED BY ops_lock: ops */
484
485         mutex_lock(&authdes_ops_lock);
486         if (ops.ah_nextverf == NULL) {
487                 ops.ah_nextverf = authdes_nextverf;
488                 ops.ah_marshal = authdes_marshal;
489                 ops.ah_validate = authdes_validate;
490                 ops.ah_refresh = authdes_refresh;
491                 ops.ah_destroy = authdes_destroy;
492         }
493         mutex_unlock(&authdes_ops_lock);
494         return (&ops);
495 }