eliminate-libaudit-requirement-20001104
[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 /*
11  * Revision 2.3  90/08/31  16:11:49
12  * Move permit_xprt.h.
13  * 
14  * Revision 2.2  90/08/20  10:05:54
15  * Include permit_xprt.h.
16  * Use stds.h.
17  * 
18  * Revision 2.1  90/08/07  18:51:45
19  * Start with clean version to sync test and dev trees.
20  * */
21 /* See RCS log for older history. */
22
23 #if defined(UKERNEL)
24 #include "../afs/param.h"
25 #include "../afs/sysincludes.h"
26 #include "../afs/afsincludes.h"
27 #include "../afs/stds.h"
28 #include "../afs/pthread_glock.h"
29 #include "../des/des.h"
30 #include "../rx/rxkad.h"
31 #include "../rx/rx.h"
32 #include "../afs/cellconfig.h"
33 #include "../afs/keys.h"
34 #include "../afs/auth.h"
35 #include "../afs/pthread_glock.h"
36 #else /* defined(UKERNEL) */
37 #include <afs/param.h>
38 #include <afs/stds.h>
39 #include <afs/pthread_glock.h>
40 #include <sys/types.h>
41 #ifdef AFS_NT40_ENV
42 #include <winsock2.h>
43 #else
44 #include <sys/file.h>
45 #include <sys/time.h>
46 #include <netinet/in.h>
47 #include <netdb.h>
48 #endif
49 #include <des.h>
50 #include <rx/rxkad.h>
51 #include <rx/rx.h>
52 #include "cellconfig.h"
53 #include "keys.h"
54 #include "auth.h"
55 #endif /* defined(UKERNEL) */
56
57
58 extern afs_int32 afsconf_Authenticate();
59 extern int afsconf_GetKey();
60 extern struct rx_securityClass *rxkad_NewServerSecurityObject();
61 extern struct rx_securityClass *rxkad_NewClientSecurityObject();
62
63 /*
64  * Note: it is necessary for the #include of permit_xprt.h occur
65  * AFTER the above declaration of rxkad_NewClientSecurityObject() --
66  * otherwise, depending on the version of permit_xprt.h that gets
67  * included, there might be a syntax error.
68  */
69
70 #if defined(UKERNEL)
71 #include "../afs/permit_xprt.h"
72 #else /* defined(UKERNEL) */
73 #include "../permit_xprt.h"
74 #endif /* defined(UKERNEL) */
75
76
77 /* return a null security object if nothing else can be done */
78 static afs_int32 QuickAuth(astr, aindex)
79 struct rx_securityClass **astr;
80 afs_int32 *aindex; {
81     register struct rx_securityClass *tc;
82     tc = (struct rx_securityClass *) rxnull_NewClientSecurityObject();
83     *astr = tc;
84     *aindex = 0;
85     return 0;
86 }
87
88 #if !defined(UKERNEL)
89 /* Return an appropriate security class and index */
90 afs_int32 afsconf_ServerAuth(adir, astr, aindex)
91 register struct afsconf_dir *adir;
92 struct rx_securityClass **astr;
93 afs_int32 *aindex; {
94     register struct rx_securityClass *tclass;
95     
96     LOCK_GLOBAL_MUTEX
97     tclass = (struct rx_securityClass *)
98         rxkad_NewServerSecurityObject(0, adir, afsconf_GetKey, (char *) 0);
99     if (tclass) {
100         *astr = tclass;
101         *aindex = 2;    /* kerberos security index */
102         UNLOCK_GLOBAL_MUTEX
103         return 0;
104     }
105     else {
106         UNLOCK_GLOBAL_MUTEX
107         return 2;
108     }
109 }
110 #endif /* !defined(UKERNEL) */
111
112 static afs_int32 GenericAuth(adir, astr, aindex, enclevel)
113 struct afsconf_dir *adir;
114 struct rx_securityClass **astr;
115 afs_int32 *aindex; 
116 rxkad_level enclevel; {
117     char tbuffer[256];
118     struct ktc_encryptionKey key, session;
119     struct rx_securityClass *tclass;
120     afs_int32 kvno;
121     afs_int32 ticketLen;
122     struct timeval tv;
123     Key_schedule schedule;
124     register afs_int32 i, code;
125     
126     /* first, find the right key and kvno to use */
127     code = afsconf_GetLatestKey(adir, &kvno, &key);
128     if (code) {
129         return QuickAuth(astr, aindex);
130     }
131     
132     /* next create random session key, using key for seed to good random */
133     des_init_random_number_generator (&key);
134     code = des_random_key (&session);
135     if (code) {
136         return QuickAuth(astr, aindex);
137     }
138     
139     /* now create the actual ticket */
140     ticketLen = sizeof(tbuffer);
141     code = tkt_MakeTicket(tbuffer, &ticketLen, &key, AUTH_SUPERUSER, "", "", 0,
142                            0xffffffff, &session, 0, "afs", "");
143     /* parms were buffer, ticketlen, key to seal ticket with, principal
144         name, instance and cell, start time, end time, session key to seal
145         in ticket, inet host, server name and server instance */
146     if (code) {
147         return QuickAuth(astr, aindex);
148     }
149
150     /* Next, we have ticket, kvno and session key, authenticate the connection.
151      * We use a magic # instead of a constant because of basic compilation
152      * order when compiling the system from scratch (rx/rxkad.h isn't installed
153      * yet). */
154     tclass = (struct rx_securityClass *)
155         rxkad_NewClientSecurityObject(enclevel, &session, kvno,
156                                       ticketLen, tbuffer);
157     *astr = tclass;
158     *aindex = 2;    /* kerberos security index */
159     return 0;
160 }
161
162 /* build a fake ticket for 'afs' using keys from adir, returning an
163  * appropriate security class and index
164  */
165 afs_int32 afsconf_ClientAuth(adir, astr, aindex)
166 struct afsconf_dir *adir;
167 struct rx_securityClass **astr;
168 afs_int32 *aindex; {
169     afs_int32 rc;
170
171     LOCK_GLOBAL_MUTEX
172     rc = GenericAuth(adir, astr, aindex, rxkad_clear);
173     UNLOCK_GLOBAL_MUTEX
174     return rc;
175 }
176
177 /* build a fake ticket for 'afs' using keys from adir, returning an
178  * appropriate security class and index.  This one, unlike the above,
179  * tells rxkad to encrypt the data, too.
180  */
181 afs_int32 afsconf_ClientAuthSecure(adir, astr, aindex)
182 struct afsconf_dir *adir;
183 struct rx_securityClass **astr;
184 afs_int32 *aindex; {
185     afs_int32 rc;
186
187     LOCK_GLOBAL_MUTEX
188     rc = GenericAuth(adir, astr, aindex, rxkad_crypt);
189     UNLOCK_GLOBAL_MUTEX
190     return rc;
191 }
192