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