Standardize License information
[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 #if !defined(UKERNEL)
78 int afsconf_CheckAuth(adir, acall)
79 register struct rx_call *acall;
80 register struct afsconf_dir *adir; {
81     LOCK_GLOBAL_MUTEX
82     return ((afsconf_SuperUser(adir, acall, (char *)0) == 0)? 10029 : 0);
83     UNLOCK_GLOBAL_MUTEX
84 }
85 #endif /* !defined(UKERNEL) */
86
87 /* return a null security object if nothing else can be done */
88 static afs_int32 QuickAuth(astr, aindex)
89 struct rx_securityClass **astr;
90 afs_int32 *aindex; {
91     register struct rx_securityClass *tc;
92     tc = (struct rx_securityClass *) rxnull_NewClientSecurityObject();
93     *astr = tc;
94     *aindex = 0;
95     return 0;
96 }
97
98 #if !defined(UKERNEL)
99 /* Return an appropriate security class and index */
100 afs_int32 afsconf_ServerAuth(adir, astr, aindex)
101 register struct afsconf_dir *adir;
102 struct rx_securityClass **astr;
103 afs_int32 *aindex; {
104     register struct rx_securityClass *tclass;
105     
106     LOCK_GLOBAL_MUTEX
107     tclass = (struct rx_securityClass *)
108         rxkad_NewServerSecurityObject(0, adir, afsconf_GetKey, (char *) 0);
109     if (tclass) {
110         *astr = tclass;
111         *aindex = 2;    /* kerberos security index */
112         UNLOCK_GLOBAL_MUTEX
113         return 0;
114     }
115     else {
116         UNLOCK_GLOBAL_MUTEX
117         return 2;
118     }
119 }
120 #endif /* !defined(UKERNEL) */
121
122 static afs_int32 GenericAuth(adir, astr, aindex, enclevel)
123 struct afsconf_dir *adir;
124 struct rx_securityClass **astr;
125 afs_int32 *aindex; 
126 rxkad_level enclevel; {
127     char tbuffer[256];
128     struct ktc_encryptionKey key, session;
129     struct rx_securityClass *tclass;
130     afs_int32 kvno;
131     afs_int32 ticketLen;
132     struct timeval tv;
133     Key_schedule schedule;
134     register afs_int32 i, code;
135     
136     /* first, find the right key and kvno to use */
137     code = afsconf_GetLatestKey(adir, &kvno, &key);
138     if (code) {
139         return QuickAuth(astr, aindex);
140     }
141     
142     /* next create random session key, using key for seed to good random */
143     des_init_random_number_generator (&key);
144     code = des_random_key (&session);
145     if (code) {
146         return QuickAuth(astr, aindex);
147     }
148     
149     /* now create the actual ticket */
150     ticketLen = sizeof(tbuffer);
151     code = tkt_MakeTicket(tbuffer, &ticketLen, &key, AUTH_SUPERUSER, "", "", 0,
152                            0xffffffff, &session, 0, "afs", "");
153     /* parms were buffer, ticketlen, key to seal ticket with, principal
154         name, instance and cell, start time, end time, session key to seal
155         in ticket, inet host, server name and server instance */
156     if (code) {
157         return QuickAuth(astr, aindex);
158     }
159
160     /* Next, we have ticket, kvno and session key, authenticate the connection.
161      * We use a magic # instead of a constant because of basic compilation
162      * order when compiling the system from scratch (rx/rxkad.h isn't installed
163      * yet). */
164     tclass = (struct rx_securityClass *)
165         rxkad_NewClientSecurityObject(enclevel, &session, kvno,
166                                       ticketLen, tbuffer);
167     *astr = tclass;
168     *aindex = 2;    /* kerberos security index */
169     return 0;
170 }
171
172 /* build a fake ticket for 'afs' using keys from adir, returning an
173  * appropriate security class and index
174  */
175 afs_int32 afsconf_ClientAuth(adir, astr, aindex)
176 struct afsconf_dir *adir;
177 struct rx_securityClass **astr;
178 afs_int32 *aindex; {
179     afs_int32 rc;
180
181     LOCK_GLOBAL_MUTEX
182     rc = GenericAuth(adir, astr, aindex, rxkad_clear);
183     UNLOCK_GLOBAL_MUTEX
184     return rc;
185 }
186
187 /* build a fake ticket for 'afs' using keys from adir, returning an
188  * appropriate security class and index.  This one, unlike the above,
189  * tells rxkad to encrypt the data, too.
190  */
191 afs_int32 afsconf_ClientAuthSecure(adir, astr, aindex)
192 struct afsconf_dir *adir;
193 struct rx_securityClass **astr;
194 afs_int32 *aindex; {
195     afs_int32 rc;
196
197     LOCK_GLOBAL_MUTEX
198     rc = GenericAuth(adir, astr, aindex, rxkad_crypt);
199     UNLOCK_GLOBAL_MUTEX
200     return rc;
201 }
202