death to trailing whitespace
[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
13 #include <afs/stds.h>
14 #include <afs/pthread_glock.h>
15 #include <sys/types.h>
16 #ifdef AFS_NT40_ENV
17 #include <winsock2.h>
18 #else
19 #include <sys/file.h>
20 #include <sys/time.h>
21 #include <netinet/in.h>
22 #include <netdb.h>
23 #endif
24 #include <string.h>
25 #include <stdio.h>
26 #include <des.h>
27 #include <des_prototypes.h>
28 #include <rx/rxkad.h>
29 #include <rx/rx.h>
30 #include "cellconfig.h"
31 #include "keys.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 #if !defined(UKERNEL)
46 /* Return an appropriate security class and index */
47 afs_int32
48 afsconf_ServerAuth(void *arock,
49                    struct rx_securityClass **astr,
50                    afs_int32 *aindex)
51 {
52     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
53     struct rx_securityClass *tclass;
54
55     LOCK_GLOBAL_MUTEX;
56     tclass = (struct rx_securityClass *)
57         rxkad_NewServerSecurityObject(0, adir, afsconf_GetKey, NULL);
58     if (tclass) {
59         *astr = tclass;
60         *aindex = RX_SECIDX_KAD;
61         UNLOCK_GLOBAL_MUTEX;
62         return 0;
63     } else {
64         UNLOCK_GLOBAL_MUTEX;
65         return 2;
66     }
67 }
68 #endif /* !defined(UKERNEL) */
69
70 static afs_int32
71 GenericAuth(struct afsconf_dir *adir,
72             struct rx_securityClass **astr,
73             afs_int32 *aindex,
74             rxkad_level enclevel)
75 {
76     char tbuffer[256];
77     struct ktc_encryptionKey key, session;
78     struct rx_securityClass *tclass;
79     afs_int32 kvno;
80     afs_int32 ticketLen;
81     afs_int32 code;
82
83     /* first, find the right key and kvno to use */
84     code = afsconf_GetLatestKey(adir, &kvno, &key);
85     if (code) {
86         return QuickAuth(astr, aindex);
87     }
88
89     /* next create random session key, using key for seed to good random */
90     des_init_random_number_generator(ktc_to_cblock(&key));
91     code = des_random_key(ktc_to_cblock(&session));
92     if (code) {
93         return QuickAuth(astr, aindex);
94     }
95
96     /* now create the actual ticket */
97     ticketLen = sizeof(tbuffer);
98     memset(tbuffer, '\0', sizeof(tbuffer));
99     code =
100         tkt_MakeTicket(tbuffer, &ticketLen, &key, AUTH_SUPERUSER, "", "", 0,
101                        0xffffffff, &session, 0, "afs", "");
102     /* parms were buffer, ticketlen, key to seal ticket with, principal
103      * name, instance and cell, start time, end time, session key to seal
104      * in ticket, inet host, server name and server instance */
105     if (code) {
106         return QuickAuth(astr, aindex);
107     }
108
109     /* Next, we have ticket, kvno and session key, authenticate the connection.
110      * We use a magic # instead of a constant because of basic compilation
111      * order when compiling the system from scratch (rx/rxkad.h isn't installed
112      * yet). */
113     tclass = (struct rx_securityClass *)
114         rxkad_NewClientSecurityObject(enclevel, &session, kvno, ticketLen,
115                                       tbuffer);
116     *astr = tclass;
117     *aindex = RX_SECIDX_KAD;
118     return 0;
119 }
120
121 /* build a fake ticket for 'afs' using keys from adir, returning an
122  * appropriate security class and index
123  */
124 afs_int32
125 afsconf_ClientAuth(void *arock, struct rx_securityClass ** astr,
126                    afs_int32 * aindex)
127 {
128     struct afsconf_dir * adir = (struct afsconf_dir *) arock;
129     afs_int32 rc;
130
131     LOCK_GLOBAL_MUTEX;
132     rc = GenericAuth(adir, astr, aindex, rxkad_clear);
133     UNLOCK_GLOBAL_MUTEX;
134     return rc;
135 }
136
137 /* build a fake ticket for 'afs' using keys from adir, returning an
138  * appropriate security class and index.  This one, unlike the above,
139  * tells rxkad to encrypt the data, too.
140  */
141 afs_int32
142 afsconf_ClientAuthSecure(void *arock,
143                          struct rx_securityClass **astr,
144                          afs_int32 *aindex)
145 {
146     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
147     afs_int32 rc;
148
149     LOCK_GLOBAL_MUTEX;
150     rc = GenericAuth(adir, astr, aindex, rxkad_crypt);
151     UNLOCK_GLOBAL_MUTEX;
152     return rc;
153 }
154
155 /*!
156  * Build a security class from the user's current tokens
157  *
158  * This function constructs an RX security class from a user's current
159  * tokens.
160  *
161  * @param[in] info      The cell information structure
162  * @param[in] flags     Security flags describing the desired mechanism
163  * @param[out] sc       The selected security class
164  * @param[out] scIndex  The index of the selected class
165  * @parma[out] expires  The expiry time of the tokens used to build the class
166  *
167  * Only the AFSCONF_SECOPTS_ALWAYSENCRYPT flag will modify the behaviour of
168  * this function - it determines whether a cleartext, or encrypting, security
169  * class is provided.
170  *
171  * @return
172  *     0 on success, non-zero on failure. An error code of
173  *     AFSCONF_NO_SECURITY_CLASS indicates that were were unable to build a
174  *     security class using the selected tokens.
175  */
176
177 afs_int32
178 afsconf_ClientAuthToken(struct afsconf_cell *info,
179                         afsconf_secflags flags,
180                         struct rx_securityClass **sc,
181                         afs_int32 *scIndex,
182                         time_t *expires)
183 {
184     struct ktc_principal sname;
185     struct ktc_token ttoken;
186     int encryptLevel;
187     afs_int32 code;
188
189     *sc = NULL;
190     *scIndex = RX_SECIDX_NULL;
191
192     strcpy(sname.cell, info->name);
193     sname.instance[0] = 0;
194     strcpy(sname.name, "afs");
195     code = ktc_GetToken(&sname, &ttoken, sizeof(ttoken), NULL);
196
197     if (code == 0) {
198         /* XXX - We should think about how to handle this */
199         if (ttoken.kvno < 0 || ttoken.kvno > 256) {
200              fprintf(stderr,
201                     "funny kvno (%d) in ticket, proceeding\n",
202                     ttoken.kvno);
203         }
204         if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
205             encryptLevel = rxkad_crypt;
206         else
207             encryptLevel = rxkad_clear;
208         *sc = rxkad_NewClientSecurityObject(encryptLevel,
209                                             &ttoken.sessionKey,
210                                             ttoken.kvno,
211                                             ttoken.ticketLen,
212                                             ttoken.ticket);
213         *scIndex = RX_SECIDX_KAD;
214         if (expires)
215             *expires = ttoken.endTime;
216     }
217     if (*sc == NULL)
218         return AFSCONF_NO_SECURITY_CLASS;
219
220     return code;
221 }
222
223 /*!
224  * Build a set of security classes suitable for a server accepting
225  * incoming connections
226  */
227 #if !defined(UKERNEL)
228 void
229 afsconf_BuildServerSecurityObjects(struct afsconf_dir *dir,
230                                    afs_uint32 flags,
231                                    struct rx_securityClass ***classes,
232                                    afs_int32 *numClasses)
233 {
234     if (flags & AFSCONF_SEC_OBJS_RXKAD_CRYPT)
235         *numClasses = 4;
236     else
237         *numClasses = 3;
238
239     *classes = calloc(*numClasses, sizeof(**classes));
240
241     (*classes)[0] = rxnull_NewServerSecurityObject();
242     (*classes)[1] = NULL;
243     (*classes)[2] = rxkad_NewServerSecurityObject(0, dir,
244                                                   afsconf_GetKey, NULL);
245     if (flags & AFSCONF_SEC_OBJS_RXKAD_CRYPT)
246         (*classes)[3] = rxkad_NewServerSecurityObject(rxkad_crypt, dir,
247                                                       afsconf_GetKey, NULL);
248 }
249 #endif
250
251 /*!
252  * Pick a security class to use for an outgoing connection
253  *
254  * This function selects an RX security class to use for an outgoing
255  * connection, based on the set of security flags provided.
256  *
257  * @param[in] dir
258  *      The configuration directory structure for this cell. If NULL,
259  *      no classes requiring local configuration will be returned.
260  * @param[in] flags
261  *      A set of flags to determine the properties of the security class which
262  *      is selected
263  *      - AFSCONF_SECOPTS_NOAUTH - return an anonymous secirty class
264  *      - AFSCONF_SECOPTS_LOCALAUTH - use classes which have local key
265  *              material available.
266  *      - AFSCONF_SECOPTS_ALWAYSENCRYPT - use classes in encrypting, rather
267  *              than authentication or integrity modes.
268  *      - AFSCONF_SECOPTS_FALLBACK_NULL - if no suitable class can be found,
269  *              then fallback to the rxnull security class.
270  * @param[in] info
271  *      The cell information structure for the current cell. If this is NULL,
272  *      then use a version locally obtained using the cellName.
273  * @param[in] cellName
274  *      The cellName to use when obtaining cell information (may be NULL if
275  *      info is specified)
276  * @param[out] sc
277  *      The selected security class
278  * @param[out] scIndex
279  *      The index of the selected security class
280  * @param[out] expires
281  *      The expiry time of the tokens used to construct the class. Will be
282  *      NEVER_DATE if the class has an unlimited lifetime. If NULL, the
283  *      function won't store the expiry date.
284  *
285  * @return
286  *      Returns 0 on success, or a com_err error code on failure.
287  */
288 afs_int32
289 afsconf_PickClientSecObj(struct afsconf_dir *dir, afsconf_secflags flags,
290                          struct afsconf_cell *info,
291                          char *cellName, struct rx_securityClass **sc,
292                          afs_int32 *scIndex, time_t *expires) {
293     struct afsconf_cell localInfo;
294     afs_int32 code = 0;
295
296     *sc = NULL;
297     *scIndex = RX_SECIDX_NULL;
298     if (expires)
299         expires = 0;
300
301     if ( !(flags & AFSCONF_SECOPTS_NOAUTH) ) {
302         if (!dir)
303             return AFSCONF_NOCELLDB;
304
305         if (flags & AFSCONF_SECOPTS_LOCALAUTH) {
306             code = afsconf_GetLatestKey(dir, 0, 0);
307             if (code)
308                 goto out;
309
310             if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
311                 code = afsconf_ClientAuthSecure(dir, sc, scIndex);
312             else
313                 code = afsconf_ClientAuth(dir, sc, scIndex);
314
315             if (code)
316                 goto out;
317
318             if (expires)
319                 *expires = NEVERDATE;
320         } else {
321             if (info == NULL) {
322                 code = afsconf_GetCellInfo(dir, cellName, NULL, &localInfo);
323                 if (code)
324                     goto out;
325                 info = &localInfo;
326             }
327
328             code = afsconf_ClientAuthToken(info, flags, sc, scIndex, expires);
329             if (code && !(flags & AFSCONF_SECOPTS_FALLBACK_NULL))
330                 goto out;
331
332             /* If we didn't get a token, we'll just run anonymously */
333             code = 0;
334         }
335     }
336     if (*sc == NULL) {
337         *sc = rxnull_NewClientSecurityObject();
338         *scIndex = RX_SECIDX_NULL;
339         if (expires)
340             *expires = NEVERDATE;
341     }
342
343 out:
344     return code;
345 }