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