aa29f79f90de6efe5dd2c6b30523dc8968b3d18d
[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     tclass = (struct rx_securityClass *)
169         rxkad_NewClientSecurityObject(enclevel, &session, kvno, ticketLen,
170                                       tbuffer);
171     *astr = tclass;
172     *aindex = RX_SECIDX_KAD;
173     return 0;
174 }
175
176 /* build a fake ticket for 'afs' using keys from adir, returning an
177  * appropriate security class and index
178  */
179 afs_int32
180 afsconf_ClientAuth(void *arock, struct rx_securityClass ** astr,
181                    afs_int32 * aindex)
182 {
183     struct afsconf_dir * adir = (struct afsconf_dir *) arock;
184     afs_int32 rc;
185
186     LOCK_GLOBAL_MUTEX;
187     rc = GenericAuth(adir, astr, aindex, rxkad_clear);
188     UNLOCK_GLOBAL_MUTEX;
189     return rc;
190 }
191
192 /* build a fake ticket for 'afs' using keys from adir, returning an
193  * appropriate security class and index.  This one, unlike the above,
194  * tells rxkad to encrypt the data, too.
195  */
196 afs_int32
197 afsconf_ClientAuthSecure(void *arock,
198                          struct rx_securityClass **astr,
199                          afs_int32 *aindex)
200 {
201     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
202     afs_int32 rc;
203
204     LOCK_GLOBAL_MUTEX;
205     rc = GenericAuth(adir, astr, aindex, rxkad_crypt);
206     UNLOCK_GLOBAL_MUTEX;
207     return rc;
208 }
209
210 /*!
211  * Build a security class from the user's current tokens
212  *
213  * This function constructs an RX security class from a user's current
214  * tokens.
215  *
216  * @param[in] info      The cell information structure
217  * @param[in] flags     Security flags describing the desired mechanism
218  * @param[out] sc       The selected security class
219  * @param[out] scIndex  The index of the selected class
220  * @parma[out] expires  The expiry time of the tokens used to build the class
221  *
222  * Only the AFSCONF_SECOPTS_ALWAYSENCRYPT flag will modify the behaviour of
223  * this function - it determines whether a cleartext, or encrypting, security
224  * class is provided.
225  *
226  * @return
227  *     0 on success, non-zero on failure. An error code of
228  *     AFSCONF_NO_SECURITY_CLASS indicates that were were unable to build a
229  *     security class using the selected tokens.
230  */
231
232 afs_int32
233 afsconf_ClientAuthToken(struct afsconf_cell *info,
234                         afsconf_secflags flags,
235                         struct rx_securityClass **sc,
236                         afs_int32 *scIndex,
237                         time_t *expires)
238 {
239     struct ktc_setTokenData *tokenSet = NULL;
240     struct ktc_token ttoken;
241     int encryptLevel;
242     afs_int32 code;
243
244     *sc = NULL;
245     *scIndex = RX_SECIDX_NULL;
246
247     code = ktc_GetTokenEx(info->name, &tokenSet);
248     if (code)
249         goto out;
250
251     code = token_extractRxkad(tokenSet, &ttoken, NULL, NULL);
252     if (code == 0) {
253         /* XXX - We should think about how to handle this */
254         if (ttoken.kvno < 0 || ttoken.kvno > 256) {
255              fprintf(stderr,
256                     "funny kvno (%d) in ticket, proceeding\n",
257                     ttoken.kvno);
258         }
259         if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
260             encryptLevel = rxkad_crypt;
261         else
262             encryptLevel = rxkad_clear;
263         *sc = rxkad_NewClientSecurityObject(encryptLevel,
264                                             &ttoken.sessionKey,
265                                             ttoken.kvno,
266                                             ttoken.ticketLen,
267                                             ttoken.ticket);
268         *scIndex = RX_SECIDX_KAD;
269         if (expires)
270             *expires = ttoken.endTime;
271     }
272
273 out:
274     token_FreeSet(&tokenSet);
275
276     if (*sc == NULL)
277         return AFSCONF_NO_SECURITY_CLASS;
278
279     return code;
280 }
281
282 /*!
283  * Set the security flags to be used for a particular configuration
284  */
285 void
286 afsconf_SetSecurityFlags(struct afsconf_dir *dir,
287                          afsconf_secflags flags)
288 {
289     dir->securityFlags = flags;
290 }
291
292 /*!
293  * Build a set of security classes suitable for a server accepting
294  * incoming connections
295  */
296 void
297 afsconf_BuildServerSecurityObjects(void *rock,
298                                    struct rx_securityClass ***classes,
299                                    afs_int32 *numClasses)
300 {
301     struct afsconf_dir *dir = rock;
302
303     if (dir->securityFlags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
304         *numClasses = 4;
305     else
306         *numClasses = 3;
307
308     *classes = calloc(*numClasses, sizeof(**classes));
309
310     (*classes)[RX_SECIDX_NULL] = rxnull_NewServerSecurityObject();
311     (*classes)[RX_SECIDX_VAB] = NULL;
312     (*classes)[RX_SECIDX_KAD] =
313         rxkad_NewKrb5ServerSecurityObject(0, dir, afsconf_GetKey,
314                                           _afsconf_GetRxkadKrb5Key, NULL);
315
316     if (dir->securityFlags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
317         (*classes)[RX_SECIDX_KAE] =
318             rxkad_NewKrb5ServerSecurityObject(rxkad_crypt, dir, afsconf_GetKey,
319                                               _afsconf_GetRxkadKrb5Key, NULL);
320 }
321
322 /*!
323  * Pick a security class to use for an outgoing connection
324  *
325  * This function selects an RX security class to use for an outgoing
326  * connection, based on the set of security flags provided.
327  *
328  * @param[in] dir
329  *      The configuration directory structure for this cell. If NULL,
330  *      no classes requiring local configuration will be returned.
331  * @param[in] flags
332  *      A set of flags to determine the properties of the security class which
333  *      is selected
334  *      - AFSCONF_SECOPTS_NOAUTH - return an anonymous secirty class
335  *      - AFSCONF_SECOPTS_LOCALAUTH - use classes which have local key
336  *              material available.
337  *      - AFSCONF_SECOPTS_ALWAYSENCRYPT - use classes in encrypting, rather
338  *              than authentication or integrity modes.
339  *      - AFSCONF_SECOPTS_FALLBACK_NULL - if no suitable class can be found,
340  *              then fallback to the rxnull security class.
341  * @param[in] info
342  *      The cell information structure for the current cell. If this is NULL,
343  *      then use a version locally obtained using the cellName.
344  * @param[in] cellName
345  *      The cellName to use when obtaining cell information (may be NULL if
346  *      info is specified)
347  * @param[out] sc
348  *      The selected security class
349  * @param[out] scIndex
350  *      The index of the selected security class
351  * @param[out] expires
352  *      The expiry time of the tokens used to construct the class. Will be
353  *      NEVER_DATE if the class has an unlimited lifetime. If NULL, the
354  *      function won't store the expiry date.
355  *
356  * @return
357  *      Returns 0 on success, or a com_err error code on failure.
358  */
359 afs_int32
360 afsconf_PickClientSecObj(struct afsconf_dir *dir, afsconf_secflags flags,
361                          struct afsconf_cell *info,
362                          char *cellName, struct rx_securityClass **sc,
363                          afs_int32 *scIndex, time_t *expires) {
364     struct afsconf_cell localInfo;
365     afs_int32 code = 0;
366
367     *sc = NULL;
368     *scIndex = RX_SECIDX_NULL;
369     if (expires)
370         *expires = 0;
371
372     if ( !(flags & AFSCONF_SECOPTS_NOAUTH) ) {
373         if (!dir)
374             return AFSCONF_NOCELLDB;
375
376         if (flags & AFSCONF_SECOPTS_LOCALAUTH) {
377             if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
378                 code = afsconf_ClientAuthSecure(dir, sc, scIndex);
379             else
380                 code = afsconf_ClientAuth(dir, sc, scIndex);
381
382             if (code)
383                 goto out;
384
385             /* The afsconf_ClientAuth functions will fall back to giving
386              * a rxnull object, which we don't want if localauth has been
387              * explicitly requested. Check for this, and bail out if we
388              * get one. Note that this leaks a security object at present
389              */
390             if (!(flags & AFSCONF_SECOPTS_FALLBACK_NULL) &&
391                 *scIndex == RX_SECIDX_NULL) {
392                 sc = NULL;
393                 code = AFSCONF_NOTFOUND;
394                 goto out;
395             }
396
397             if (expires)
398                 *expires = NEVERDATE;
399         } else {
400             if (info == NULL) {
401                 code = afsconf_GetCellInfo(dir, cellName, NULL, &localInfo);
402                 if (code)
403                     goto out;
404                 info = &localInfo;
405             }
406
407             code = afsconf_ClientAuthToken(info, flags, sc, scIndex, expires);
408             if (code && !(flags & AFSCONF_SECOPTS_FALLBACK_NULL))
409                 goto out;
410
411             /* If we didn't get a token, we'll just run anonymously */
412             code = 0;
413         }
414     }
415     if (*sc == NULL) {
416         *sc = rxnull_NewClientSecurityObject();
417         *scIndex = RX_SECIDX_NULL;
418         if (expires)
419             *expires = NEVERDATE;
420     }
421
422 out:
423     return code;
424 }