Make OpenAFS 1.9.0
[openafs.git] / src / auth / authcon.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12 #include <afs/stds.h>
13
14 #include <roken.h>
15
16 #ifdef IGNORE_SOME_GCC_WARNINGS
17 # pragma GCC diagnostic warning "-Wdeprecated-declarations"
18 #endif
19
20 #define HC_DEPRECATED
21 #include <hcrypto/des.h>
22 #include <hcrypto/rand.h>
23
24 #include <rx/rxkad.h>
25 #include <rx/rx.h>
26
27 #include <afs/pthread_glock.h>
28
29 #include "cellconfig.h"
30 #include "keys.h"
31 #include "ktc.h"
32 #include "auth.h"
33
34 #ifdef AFS_RXGK_ENV
35 # include <rx/rxgk.h>
36 #endif
37
38 /* return a null security object if nothing else can be done */
39 static afs_int32
40 QuickAuth(struct rx_securityClass **astr, afs_int32 *aindex)
41 {
42     struct rx_securityClass *tc;
43     tc = rxnull_NewClientSecurityObject();
44     *astr = tc;
45     *aindex = RX_SECIDX_NULL;
46     return 0;
47 }
48
49 static int _afsconf_GetRxkadKrb5Key(void *arock, int kvno, int enctype, void *outkey,
50                                     size_t *keylen)
51 {
52     struct afsconf_dir *adir = arock;
53     struct afsconf_typedKey *kobj;
54     struct rx_opaque *keymat;
55     afsconf_keyType tktype;
56     int tkvno, tenctype;
57     int code;
58
59     code = afsconf_GetKeyByTypes(adir, afsconf_rxkad_krb5, kvno, enctype, &kobj);
60     if (code != 0)
61         return code;
62     afsconf_typedKey_values(kobj, &tktype, &tkvno, &tenctype, &keymat);
63     if (*keylen < keymat->len) {
64         afsconf_typedKey_put(&kobj);
65         return AFSCONF_BADKEY;
66     }
67     memcpy(outkey, keymat->val, keymat->len);
68     *keylen = keymat->len;
69     afsconf_typedKey_put(&kobj);
70     return 0;
71 }
72
73
74 /* Return an appropriate security class and index */
75 afs_int32
76 afsconf_ServerAuth(void *arock,
77                    struct rx_securityClass **astr,
78                    afs_int32 *aindex)
79 {
80     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
81     struct rx_securityClass *tclass;
82
83     LOCK_GLOBAL_MUTEX;
84     tclass = (struct rx_securityClass *)
85         rxkad_NewKrb5ServerSecurityObject(0, adir, afsconf_GetKey,
86                                           _afsconf_GetRxkadKrb5Key, NULL);
87     if (tclass) {
88         *astr = tclass;
89         *aindex = RX_SECIDX_KAD;
90         UNLOCK_GLOBAL_MUTEX;
91         return 0;
92     } else {
93         UNLOCK_GLOBAL_MUTEX;
94         return 2;
95     }
96 }
97
98 static afs_int32
99 GenericAuth(struct afsconf_dir *adir,
100             struct rx_securityClass **astr,
101             afs_int32 *aindex,
102             rxkad_level enclevel)
103 {
104     int enctype_preflist[]={18, 17, 23, 16, 0};
105     char tbuffer[512];
106     struct ktc_encryptionKey key, session;
107     struct rx_securityClass *tclass;
108     afs_int32 kvno;
109     afs_int32 ticketLen;
110     afs_int32 code;
111     int use_krb5=0;
112     struct afsconf_typedKey *kobj;
113     struct rx_opaque *keymat;
114     int *et;
115
116     /* first, find the right key and kvno to use */
117
118     et = enctype_preflist;
119     while(*et != 0) {
120         code = afsconf_GetLatestKeyByTypes(adir, afsconf_rxkad_krb5, *et,
121                                            &kobj);
122         if (code == 0) {
123             afsconf_keyType tktype;
124             int tenctype;
125             afsconf_typedKey_values(kobj, &tktype, &kvno, &tenctype, &keymat);
126             RAND_add(keymat->val, keymat->len, 0.0);
127             use_krb5 = 1;
128             break;
129         }
130         et++;
131     }
132
133     if (use_krb5 == 0) {
134         code = afsconf_GetLatestKey(adir, &kvno, &key);
135         if (code) {
136             return QuickAuth(astr, aindex);
137         }
138         /* next create random session key, using key for seed to good random */
139         DES_init_random_number_generator((DES_cblock *) &key);
140     }
141     code = DES_new_random_key((DES_cblock *) &session);
142     if (code) {
143         if (use_krb5)
144             afsconf_typedKey_put(&kobj);
145         return QuickAuth(astr, aindex);
146     }
147
148     if (use_krb5) {
149         ticketLen = sizeof(tbuffer);
150         memset(tbuffer, '\0', sizeof(tbuffer));
151         code =
152             tkt_MakeTicket5(tbuffer, &ticketLen, *et, &kvno, keymat->val,
153                             keymat->len, AUTH_SUPERUSER, "", "", 0, 0x7fffffff,
154                             &session, "afs", "");
155         afsconf_typedKey_put(&kobj);
156     } else {
157         /* now create the actual ticket */
158         ticketLen = sizeof(tbuffer);
159         memset(tbuffer, '\0', sizeof(tbuffer));
160         code =
161             tkt_MakeTicket(tbuffer, &ticketLen, &key, AUTH_SUPERUSER, "", "", 0,
162                            0xffffffff, &session, 0, "afs", "");
163         /* parms were buffer, ticketlen, key to seal ticket with, principal
164          * name, instance and cell, start time, end time, session key to seal
165          * in ticket, inet host, server name and server instance */
166     }
167     if (code) {
168         return QuickAuth(astr, aindex);
169     }
170
171     /* Next, we have ticket, kvno and session key, authenticate the connection.*/
172     tclass = (struct rx_securityClass *)
173         rxkad_NewClientSecurityObject(enclevel, &session, kvno, ticketLen,
174                                       tbuffer);
175     *astr = tclass;
176     *aindex = RX_SECIDX_KAD;
177     return 0;
178 }
179
180 /* build a fake ticket for 'afs' using keys from adir, returning an
181  * appropriate security class and index
182  */
183 afs_int32
184 afsconf_ClientAuth(void *arock, struct rx_securityClass ** astr,
185                    afs_int32 * aindex)
186 {
187     struct afsconf_dir * adir = (struct afsconf_dir *) arock;
188     afs_int32 rc;
189
190     LOCK_GLOBAL_MUTEX;
191     rc = GenericAuth(adir, astr, aindex, rxkad_clear);
192     UNLOCK_GLOBAL_MUTEX;
193     return rc;
194 }
195
196 /* build a fake ticket for 'afs' using keys from adir, returning an
197  * appropriate security class and index.  This one, unlike the above,
198  * tells rxkad to encrypt the data, too.
199  */
200 afs_int32
201 afsconf_ClientAuthSecure(void *arock,
202                          struct rx_securityClass **astr,
203                          afs_int32 *aindex)
204 {
205     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
206     afs_int32 rc;
207
208     LOCK_GLOBAL_MUTEX;
209     rc = GenericAuth(adir, astr, aindex, rxkad_crypt);
210     UNLOCK_GLOBAL_MUTEX;
211     return rc;
212 }
213
214 /**
215  * Print an rxgk token and make a security class with it
216  *
217  * Print an rxgk token and build a security class from it, returning the
218  * correct index along with the class.
219  *
220  * As with the other ClientAuth variants, fall back to rxnull on errors.
221  * The caller can check the returned aindex if necessary.
222  *
223  * If 'crypt' is nonzero, use the _CRYPT security level. Otherwise, if 'auth'
224  * is nonzero, use the _AUTH security level. Otherwise, use _CLEAR.
225  */
226 static afs_int32
227 _ClientAuthRXGK(void *arock, struct rx_securityClass **aclass,
228                 afs_int32 *aindex, int crypt, int auth)
229 {
230 #ifdef AFS_RXGK_ENV
231     struct rx_securityClass *tclass;
232     struct rx_opaque token = RX_EMPTY_OPAQUE;
233     RXGK_Level level;
234     RXGK_TokenInfo tokeninfo;
235     rxgk_key cell_key = NULL, k0 = NULL;
236     afs_int32 code, kvno, cell_enctype, k0_enctype;
237
238     memset(&tokeninfo, 0, sizeof(tokeninfo));
239
240     if (crypt)
241         level = RXGK_LEVEL_CRYPT;
242     else if (auth)
243         level = RXGK_LEVEL_AUTH;
244     else
245         level = RXGK_LEVEL_CLEAR;
246
247     code = afsconf_GetLatestRXGKKey(arock, &kvno, &cell_enctype, &cell_key);
248     if (code != 0)
249         goto done;
250
251     /* assume that cell_key's enctype works for the our token's k0, too */
252     k0_enctype = cell_enctype;
253
254     tokeninfo.enctype = k0_enctype;
255     tokeninfo.level = level;
256     code = rxgk_print_token_and_key(&token, &tokeninfo, cell_key, kvno,
257                                     cell_enctype, &k0);
258     if (code != 0)
259         goto done;
260     tclass = rxgk_NewClientSecurityObject(level, k0_enctype, k0, &token);
261     if (tclass == NULL)
262         code = RXGK_INCONSISTENCY;
263  done:
264     rxgk_release_key(&cell_key);
265     rxgk_release_key(&k0);
266     rx_opaque_freeContents(&token);
267     if (code != 0)
268         return QuickAuth(aclass, aindex);
269     *aclass = tclass;
270     *aindex = RX_SECIDX_GK;
271     return code;
272 #else   /* AFS_RXGK_ENV */
273     return QuickAuth(aclass, aindex);
274 #endif  /* !AFS_RXGK_ENV */
275 }
276
277 afs_int32
278 afsconf_ClientAuthRXGKClear(void *arock, struct rx_securityClass **aclass,
279                             afs_int32 *aindex)
280 {
281     return _ClientAuthRXGK(arock, aclass, aindex, 0, 0);
282 }
283
284 afs_int32
285 afsconf_ClientAuthRXGKAuth(void *arock, struct rx_securityClass **aclass,
286                             afs_int32 *aindex)
287 {
288     return _ClientAuthRXGK(arock, aclass, aindex, 0, 1);
289 }
290
291 afs_int32
292 afsconf_ClientAuthRXGKCrypt(void *arock, struct rx_securityClass **aclass,
293                             afs_int32 *aindex)
294 {
295     return _ClientAuthRXGK(arock, aclass, aindex, 1, 0);
296 }
297
298 /*!
299  * Build a security class from the user's current tokens
300  *
301  * This function constructs an RX security class from a user's current
302  * tokens.
303  *
304  * @param[in] info      The cell information structure
305  * @param[in] flags     Security flags describing the desired mechanism
306  * @param[out] sc       The selected security class
307  * @param[out] scIndex  The index of the selected class
308  * @parma[out] expires  The expiry time of the tokens used to build the class
309  *
310  * Only the AFSCONF_SECOPTS_ALWAYSENCRYPT flag will modify the behaviour of
311  * this function - it determines whether a cleartext, or encrypting, security
312  * class is provided.
313  *
314  * @return
315  *     0 on success, non-zero on failure. An error code of
316  *     AFSCONF_NO_SECURITY_CLASS indicates that were were unable to build a
317  *     security class using the selected tokens.
318  */
319
320 afs_int32
321 afsconf_ClientAuthToken(struct afsconf_cell *info,
322                         afsconf_secflags flags,
323                         struct rx_securityClass **sc,
324                         afs_int32 *scIndex,
325                         time_t *expires)
326 {
327     struct ktc_setTokenData *tokenSet = NULL;
328     struct ktc_token ttoken;
329     int encryptLevel;
330     afs_int32 code;
331
332     *sc = NULL;
333     *scIndex = RX_SECIDX_NULL;
334
335     if ((flags & AFSCONF_SECOPTS_RXGK)) {
336         /* We don't support non-printed rxgk tokens yet */
337         code = AFSCONF_NO_SECURITY_CLASS;
338         goto out;
339     }
340
341     code = ktc_GetTokenEx(info->name, &tokenSet);
342     if (code)
343         goto out;
344
345     code = token_extractRxkad(tokenSet, &ttoken, NULL, NULL);
346     if (code == 0) {
347         /* XXX - We should think about how to handle this */
348         if (ttoken.kvno < 0 || ttoken.kvno > 256) {
349              fprintf(stderr,
350                     "funny kvno (%d) in ticket, proceeding\n",
351                     ttoken.kvno);
352         }
353         if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
354             encryptLevel = rxkad_crypt;
355         else
356             encryptLevel = rxkad_clear;
357         *sc = rxkad_NewClientSecurityObject(encryptLevel,
358                                             &ttoken.sessionKey,
359                                             ttoken.kvno,
360                                             ttoken.ticketLen,
361                                             ttoken.ticket);
362         *scIndex = RX_SECIDX_KAD;
363         if (expires)
364             *expires = ttoken.endTime;
365     }
366
367 out:
368     token_FreeSet(&tokenSet);
369
370     if (*sc == NULL)
371         return AFSCONF_NO_SECURITY_CLASS;
372
373     return code;
374 }
375
376 /*!
377  * Set the security flags to be used for a particular configuration
378  */
379 void
380 afsconf_SetSecurityFlags(struct afsconf_dir *dir,
381                          afsconf_secflags flags)
382 {
383     dir->securityFlags = flags;
384 }
385
386 /*!
387  * Build a set of security classes suitable for a server accepting
388  * incoming connections
389  */
390 void
391 afsconf_BuildServerSecurityObjects(void *rock,
392                                    struct rx_securityClass ***classes,
393                                    afs_int32 *numClasses)
394 {
395     struct afsconf_dir *dir = rock;
396
397     *numClasses = RX_SECIDX_GK+1;
398
399     *classes = calloc(*numClasses, sizeof(**classes));
400
401     (*classes)[RX_SECIDX_NULL] = rxnull_NewServerSecurityObject();
402     (*classes)[RX_SECIDX_KAD] =
403         rxkad_NewKrb5ServerSecurityObject(0, dir, afsconf_GetKey,
404                                           _afsconf_GetRxkadKrb5Key, NULL);
405
406     if (dir->securityFlags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
407         (*classes)[RX_SECIDX_KAE] =
408             rxkad_NewKrb5ServerSecurityObject(rxkad_crypt, dir, afsconf_GetKey,
409                                               _afsconf_GetRxkadKrb5Key, NULL);
410 #ifdef AFS_RXGK_ENV
411     (*classes)[RX_SECIDX_GK] =
412         rxgk_NewServerSecurityObject(rock, afsconf_GetRXGKKey);
413 #endif
414 }
415
416 /*!
417  * Pick a security class to use for an outgoing connection
418  *
419  * This function selects an RX security class to use for an outgoing
420  * connection, based on the set of security flags provided.
421  *
422  * @param[in] dir
423  *      The configuration directory structure for this cell. If NULL,
424  *      no classes requiring local configuration will be returned.
425  * @param[in] flags
426  *      A set of flags to determine the properties of the security class which
427  *      is selected
428  *      - AFSCONF_SECOPTS_NOAUTH - return an anonymous secirty class
429  *      - AFSCONF_SECOPTS_LOCALAUTH - use classes which have local key
430  *              material available.
431  *      - AFSCONF_SECOPTS_ALWAYSENCRYPT - use classes in encrypting, rather
432  *              than authentication or integrity modes.
433  *      - AFSCONF_SECOPTS_FALLBACK_NULL - if no suitable class can be found,
434  *              then fallback to the rxnull security class.
435  *      - AFSCONF_SECOPTS_NEVERENCRYPT - avoid encrypting classes (currently
436  *              only valid with _RXGK)
437  *      - AFSCONF_SECOPTS_ALWAYSCLEAR - avoid encrypting or authenticating
438  *              classes (always use "clear" security classes) (currently
439  *              only valid with _RXGK)
440  *      - AFSCONF_SECOPTS_RXGK - only use rxgk security classes (currently
441  *              only valid with _LOCALAUTH)
442  * @param[in] info
443  *      The cell information structure for the current cell. If this is NULL,
444  *      then use a version locally obtained using the cellName.
445  * @param[in] cellName
446  *      The cellName to use when obtaining cell information (may be NULL if
447  *      info is specified)
448  * @param[out] sc
449  *      The selected security class
450  * @param[out] scIndex
451  *      The index of the selected security class
452  * @param[out] expires
453  *      The expiry time of the tokens used to construct the class. Will be
454  *      NEVER_DATE if the class has an unlimited lifetime. If NULL, the
455  *      function won't store the expiry date.
456  *
457  * @return
458  *      Returns 0 on success, or a com_err error code on failure.
459  */
460 afs_int32
461 afsconf_PickClientSecObj(struct afsconf_dir *dir, afsconf_secflags flags,
462                          struct afsconf_cell *info,
463                          char *cellName, struct rx_securityClass **sc,
464                          afs_int32 *scIndex, time_t *expires) {
465     struct afsconf_cell localInfo;
466     afs_int32 code = 0;
467
468     *sc = NULL;
469     *scIndex = RX_SECIDX_NULL;
470     if (expires)
471         *expires = 0;
472
473     if ( !(flags & AFSCONF_SECOPTS_NOAUTH) ) {
474         if (!dir)
475             return AFSCONF_NOCELLDB;
476
477         if (flags & AFSCONF_SECOPTS_LOCALAUTH) {
478             if ((flags & AFSCONF_SECOPTS_RXGK)) {
479                 if ((flags & AFSCONF_SECOPTS_ALWAYSCLEAR))
480                     code = afsconf_ClientAuthRXGKClear(dir, sc, scIndex);
481                 else if ((flags & AFSCONF_SECOPTS_NEVERENCRYPT))
482                     code = afsconf_ClientAuthRXGKAuth(dir, sc, scIndex);
483                 else
484                     code = afsconf_ClientAuthRXGKCrypt(dir, sc, scIndex);
485
486             } else if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
487                 code = afsconf_ClientAuthSecure(dir, sc, scIndex);
488             else
489                 code = afsconf_ClientAuth(dir, sc, scIndex);
490
491             if (code)
492                 goto out;
493
494             /* The afsconf_ClientAuth functions will fall back to giving
495              * a rxnull object, which we don't want if localauth has been
496              * explicitly requested. Check for this, and bail out if we
497              * get one. Note that this leaks a security object at present
498              */
499             if (!(flags & AFSCONF_SECOPTS_FALLBACK_NULL) &&
500                 *scIndex == RX_SECIDX_NULL) {
501                 sc = NULL;
502                 code = AFSCONF_NOTFOUND;
503                 goto out;
504             }
505
506             if (expires)
507                 *expires = NEVERDATE;
508         } else {
509             if (info == NULL) {
510                 code = afsconf_GetCellInfo(dir, cellName, NULL, &localInfo);
511                 if (code)
512                     goto out;
513                 info = &localInfo;
514             }
515
516             code = afsconf_ClientAuthToken(info, flags, sc, scIndex, expires);
517             if (code && !(flags & AFSCONF_SECOPTS_FALLBACK_NULL))
518                 goto out;
519
520             /* If we didn't get a token, we'll just run anonymously */
521             code = 0;
522         }
523     }
524     if (*sc == NULL) {
525         *sc = rxnull_NewClientSecurityObject();
526         *scIndex = RX_SECIDX_NULL;
527         if (expires)
528             *expires = NEVERDATE;
529     }
530
531 out:
532     return code;
533 }