Remove UKERNEL code from files that don't need it
[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 /* return a null security object if nothing else can be done */
35 static afs_int32
36 QuickAuth(struct rx_securityClass **astr, afs_int32 *aindex)
37 {
38     struct rx_securityClass *tc;
39     tc = rxnull_NewClientSecurityObject();
40     *astr = tc;
41     *aindex = RX_SECIDX_NULL;
42     return 0;
43 }
44
45 static int _afsconf_GetRxkadKrb5Key(void *arock, int kvno, int enctype, void *outkey,
46                                     size_t *keylen)
47 {
48     struct afsconf_dir *adir = arock;
49     struct afsconf_typedKey *kobj;
50     struct rx_opaque *keymat;
51     afsconf_keyType tktype;
52     int tkvno, tenctype;
53     int code;
54
55     code = afsconf_GetKeyByTypes(adir, afsconf_rxkad_krb5, kvno, enctype, &kobj);
56     if (code != 0)
57         return code;
58     afsconf_typedKey_values(kobj, &tktype, &tkvno, &tenctype, &keymat);
59     if (*keylen < keymat->len) {
60         afsconf_typedKey_put(&kobj);
61         return AFSCONF_BADKEY;
62     }
63     memcpy(outkey, keymat->val, keymat->len);
64     *keylen = keymat->len;
65     afsconf_typedKey_put(&kobj);
66     return 0;
67 }
68
69
70 /* Return an appropriate security class and index */
71 afs_int32
72 afsconf_ServerAuth(void *arock,
73                    struct rx_securityClass **astr,
74                    afs_int32 *aindex)
75 {
76     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
77     struct rx_securityClass *tclass;
78
79     LOCK_GLOBAL_MUTEX;
80     tclass = (struct rx_securityClass *)
81         rxkad_NewKrb5ServerSecurityObject(0, adir, afsconf_GetKey,
82                                           _afsconf_GetRxkadKrb5Key, NULL);
83     if (tclass) {
84         *astr = tclass;
85         *aindex = RX_SECIDX_KAD;
86         UNLOCK_GLOBAL_MUTEX;
87         return 0;
88     } else {
89         UNLOCK_GLOBAL_MUTEX;
90         return 2;
91     }
92 }
93
94 static afs_int32
95 GenericAuth(struct afsconf_dir *adir,
96             struct rx_securityClass **astr,
97             afs_int32 *aindex,
98             rxkad_level enclevel)
99 {
100     int enctype_preflist[]={18, 17, 23, 16, 0};
101     char tbuffer[512];
102     struct ktc_encryptionKey key, session;
103     struct rx_securityClass *tclass;
104     afs_int32 kvno;
105     afs_int32 ticketLen;
106     afs_int32 code;
107     int use_krb5=0;
108     struct afsconf_typedKey *kobj;
109     struct rx_opaque *keymat;
110     int *et;
111
112     /* first, find the right key and kvno to use */
113
114     et = enctype_preflist;
115     while(*et != 0) {
116         code = afsconf_GetLatestKeyByTypes(adir, afsconf_rxkad_krb5, *et,
117                                            &kobj);
118         if (code == 0) {
119             afsconf_keyType tktype;
120             int tenctype;
121             afsconf_typedKey_values(kobj, &tktype, &kvno, &tenctype, &keymat);
122             RAND_add(keymat->val, keymat->len, 0.0);
123             use_krb5 = 1;
124             break;
125         }
126         et++;
127     }
128
129     if (use_krb5 == 0) {
130         code = afsconf_GetLatestKey(adir, &kvno, &key);
131         if (code) {
132             return QuickAuth(astr, aindex);
133         }
134         /* next create random session key, using key for seed to good random */
135         DES_init_random_number_generator((DES_cblock *) &key);
136     }
137     code = DES_new_random_key((DES_cblock *) &session);
138     if (code) {
139         if (use_krb5)
140             afsconf_typedKey_put(&kobj);
141         return QuickAuth(astr, aindex);
142     }
143
144     if (use_krb5) {
145         ticketLen = sizeof(tbuffer);
146         memset(tbuffer, '\0', sizeof(tbuffer));
147         code =
148             tkt_MakeTicket5(tbuffer, &ticketLen, *et, &kvno, keymat->val,
149                             keymat->len, AUTH_SUPERUSER, "", "", 0, 0x7fffffff,
150                             &session, "afs", "");
151         afsconf_typedKey_put(&kobj);
152     } else {
153         /* now create the actual ticket */
154         ticketLen = sizeof(tbuffer);
155         memset(tbuffer, '\0', sizeof(tbuffer));
156         code =
157             tkt_MakeTicket(tbuffer, &ticketLen, &key, AUTH_SUPERUSER, "", "", 0,
158                            0xffffffff, &session, 0, "afs", "");
159         /* parms were buffer, ticketlen, key to seal ticket with, principal
160          * name, instance and cell, start time, end time, session key to seal
161          * in ticket, inet host, server name and server instance */
162     }
163     if (code) {
164         return QuickAuth(astr, aindex);
165     }
166
167     /* Next, we have ticket, kvno and session key, authenticate the connection.
168      * We use a magic # instead of a constant because of basic compilation
169      * order when compiling the system from scratch (rx/rxkad.h isn't installed
170      * yet). */
171     tclass = (struct rx_securityClass *)
172         rxkad_NewClientSecurityObject(enclevel, &session, kvno, ticketLen,
173                                       tbuffer);
174     *astr = tclass;
175     *aindex = RX_SECIDX_KAD;
176     return 0;
177 }
178
179 /* build a fake ticket for 'afs' using keys from adir, returning an
180  * appropriate security class and index
181  */
182 afs_int32
183 afsconf_ClientAuth(void *arock, struct rx_securityClass ** astr,
184                    afs_int32 * aindex)
185 {
186     struct afsconf_dir * adir = (struct afsconf_dir *) arock;
187     afs_int32 rc;
188
189     LOCK_GLOBAL_MUTEX;
190     rc = GenericAuth(adir, astr, aindex, rxkad_clear);
191     UNLOCK_GLOBAL_MUTEX;
192     return rc;
193 }
194
195 /* build a fake ticket for 'afs' using keys from adir, returning an
196  * appropriate security class and index.  This one, unlike the above,
197  * tells rxkad to encrypt the data, too.
198  */
199 afs_int32
200 afsconf_ClientAuthSecure(void *arock,
201                          struct rx_securityClass **astr,
202                          afs_int32 *aindex)
203 {
204     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
205     afs_int32 rc;
206
207     LOCK_GLOBAL_MUTEX;
208     rc = GenericAuth(adir, astr, aindex, rxkad_crypt);
209     UNLOCK_GLOBAL_MUTEX;
210     return rc;
211 }
212
213 /*!
214  * Build a security class from the user's current tokens
215  *
216  * This function constructs an RX security class from a user's current
217  * tokens.
218  *
219  * @param[in] info      The cell information structure
220  * @param[in] flags     Security flags describing the desired mechanism
221  * @param[out] sc       The selected security class
222  * @param[out] scIndex  The index of the selected class
223  * @parma[out] expires  The expiry time of the tokens used to build the class
224  *
225  * Only the AFSCONF_SECOPTS_ALWAYSENCRYPT flag will modify the behaviour of
226  * this function - it determines whether a cleartext, or encrypting, security
227  * class is provided.
228  *
229  * @return
230  *     0 on success, non-zero on failure. An error code of
231  *     AFSCONF_NO_SECURITY_CLASS indicates that were were unable to build a
232  *     security class using the selected tokens.
233  */
234
235 afs_int32
236 afsconf_ClientAuthToken(struct afsconf_cell *info,
237                         afsconf_secflags flags,
238                         struct rx_securityClass **sc,
239                         afs_int32 *scIndex,
240                         time_t *expires)
241 {
242     struct ktc_setTokenData *tokenSet = NULL;
243     struct ktc_token ttoken;
244     int encryptLevel;
245     afs_int32 code;
246
247     *sc = NULL;
248     *scIndex = RX_SECIDX_NULL;
249
250     code = ktc_GetTokenEx(info->name, &tokenSet);
251     if (code)
252         goto out;
253
254     code = token_extractRxkad(tokenSet, &ttoken, NULL, NULL);
255     if (code == 0) {
256         /* XXX - We should think about how to handle this */
257         if (ttoken.kvno < 0 || ttoken.kvno > 256) {
258              fprintf(stderr,
259                     "funny kvno (%d) in ticket, proceeding\n",
260                     ttoken.kvno);
261         }
262         if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
263             encryptLevel = rxkad_crypt;
264         else
265             encryptLevel = rxkad_clear;
266         *sc = rxkad_NewClientSecurityObject(encryptLevel,
267                                             &ttoken.sessionKey,
268                                             ttoken.kvno,
269                                             ttoken.ticketLen,
270                                             ttoken.ticket);
271         *scIndex = RX_SECIDX_KAD;
272         if (expires)
273             *expires = ttoken.endTime;
274     }
275
276 out:
277     token_FreeSet(&tokenSet);
278
279     if (*sc == NULL)
280         return AFSCONF_NO_SECURITY_CLASS;
281
282     return code;
283 }
284
285 /*!
286  * Set the security flags to be used for a particular configuration
287  */
288 void
289 afsconf_SetSecurityFlags(struct afsconf_dir *dir,
290                          afsconf_secflags flags)
291 {
292     dir->securityFlags = flags;
293 }
294
295 /*!
296  * Build a set of security classes suitable for a server accepting
297  * incoming connections
298  */
299 void
300 afsconf_BuildServerSecurityObjects(void *rock,
301                                    struct rx_securityClass ***classes,
302                                    afs_int32 *numClasses)
303 {
304     struct afsconf_dir *dir = rock;
305
306     if (dir->securityFlags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
307         *numClasses = 4;
308     else
309         *numClasses = 3;
310
311     *classes = calloc(*numClasses, sizeof(**classes));
312
313     (*classes)[RX_SECIDX_NULL] = rxnull_NewServerSecurityObject();
314     (*classes)[RX_SECIDX_VAB] = NULL;
315     (*classes)[RX_SECIDX_KAD] =
316         rxkad_NewKrb5ServerSecurityObject(0, dir, afsconf_GetKey,
317                                           _afsconf_GetRxkadKrb5Key, NULL);
318
319     if (dir->securityFlags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
320         (*classes)[RX_SECIDX_KAE] =
321             rxkad_NewKrb5ServerSecurityObject(rxkad_crypt, dir, afsconf_GetKey,
322                                               _afsconf_GetRxkadKrb5Key, NULL);
323 }
324
325 /*!
326  * Pick a security class to use for an outgoing connection
327  *
328  * This function selects an RX security class to use for an outgoing
329  * connection, based on the set of security flags provided.
330  *
331  * @param[in] dir
332  *      The configuration directory structure for this cell. If NULL,
333  *      no classes requiring local configuration will be returned.
334  * @param[in] flags
335  *      A set of flags to determine the properties of the security class which
336  *      is selected
337  *      - AFSCONF_SECOPTS_NOAUTH - return an anonymous secirty class
338  *      - AFSCONF_SECOPTS_LOCALAUTH - use classes which have local key
339  *              material available.
340  *      - AFSCONF_SECOPTS_ALWAYSENCRYPT - use classes in encrypting, rather
341  *              than authentication or integrity modes.
342  *      - AFSCONF_SECOPTS_FALLBACK_NULL - if no suitable class can be found,
343  *              then fallback to the rxnull security class.
344  * @param[in] info
345  *      The cell information structure for the current cell. If this is NULL,
346  *      then use a version locally obtained using the cellName.
347  * @param[in] cellName
348  *      The cellName to use when obtaining cell information (may be NULL if
349  *      info is specified)
350  * @param[out] sc
351  *      The selected security class
352  * @param[out] scIndex
353  *      The index of the selected security class
354  * @param[out] expires
355  *      The expiry time of the tokens used to construct the class. Will be
356  *      NEVER_DATE if the class has an unlimited lifetime. If NULL, the
357  *      function won't store the expiry date.
358  *
359  * @return
360  *      Returns 0 on success, or a com_err error code on failure.
361  */
362 afs_int32
363 afsconf_PickClientSecObj(struct afsconf_dir *dir, afsconf_secflags flags,
364                          struct afsconf_cell *info,
365                          char *cellName, struct rx_securityClass **sc,
366                          afs_int32 *scIndex, time_t *expires) {
367     struct afsconf_cell localInfo;
368     afs_int32 code = 0;
369
370     *sc = NULL;
371     *scIndex = RX_SECIDX_NULL;
372     if (expires)
373         *expires = 0;
374
375     if ( !(flags & AFSCONF_SECOPTS_NOAUTH) ) {
376         if (!dir)
377             return AFSCONF_NOCELLDB;
378
379         if (flags & AFSCONF_SECOPTS_LOCALAUTH) {
380             if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
381                 code = afsconf_ClientAuthSecure(dir, sc, scIndex);
382             else
383                 code = afsconf_ClientAuth(dir, sc, scIndex);
384
385             if (code)
386                 goto out;
387
388             /* The afsconf_ClientAuth functions will fall back to giving
389              * a rxnull object, which we don't want if localauth has been
390              * explicitly requested. Check for this, and bail out if we
391              * get one. Note that this leaks a security object at present
392              */
393             if (!(flags & AFSCONF_SECOPTS_FALLBACK_NULL) &&
394                 *scIndex == RX_SECIDX_NULL) {
395                 sc = NULL;
396                 code = AFSCONF_NOTFOUND;
397                 goto out;
398             }
399
400             if (expires)
401                 *expires = NEVERDATE;
402         } else {
403             if (info == NULL) {
404                 code = afsconf_GetCellInfo(dir, cellName, NULL, &localInfo);
405                 if (code)
406                     goto out;
407                 info = &localInfo;
408             }
409
410             code = afsconf_ClientAuthToken(info, flags, sc, scIndex, expires);
411             if (code && !(flags & AFSCONF_SECOPTS_FALLBACK_NULL))
412                 goto out;
413
414             /* If we didn't get a token, we'll just run anonymously */
415             code = 0;
416         }
417     }
418     if (*sc == NULL) {
419         *sc = rxnull_NewClientSecurityObject();
420         *scIndex = RX_SECIDX_NULL;
421         if (expires)
422             *expires = NEVERDATE;
423     }
424
425 out:
426     return code;
427 }