pod-updates-20060227
[openafs.git] / src / rxkad / rxkad_client.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 /* The rxkad security object.  Authentication using a DES-encrypted
11  * Kerberos-style ticket.  These are the client-only routines.  They do not
12  * make any use of DES. */
13
14 #include <afsconfig.h>
15 #ifdef KERNEL
16 #include "afs/param.h"
17 #else
18 #include <afs/param.h>
19 #endif
20
21 RCSID
22     ("$Header$");
23
24 #ifdef KERNEL
25 #include "afs/stds.h"
26 #ifndef UKERNEL
27 #include "h/types.h"
28 #include "h/time.h"
29 #ifdef AFS_LINUX20_ENV
30 #include "h/socket.h"
31 #endif
32 #ifndef AFS_OBSD_ENV
33 #include "netinet/in.h"
34 #endif
35 #else /* !UKERNEL */
36 #include "afs/sysincludes.h"
37 #endif /* !UKERNEL */
38 #ifndef AFS_LINUX22_ENV
39 #include "rpc/types.h"
40 #include "rx/xdr.h"
41 #endif
42 #include "rx/rx.h"
43 #else /* ! KERNEL */
44 #include <afs/stds.h>
45 #include <sys/types.h>
46 #include <time.h>
47 #ifdef HAVE_STRING_H
48 #include <string.h>
49 #else
50 #ifdef HAVE_STRINGS_H
51 #include <strings.h>
52 #endif
53 #endif
54 #ifdef AFS_NT40_ENV
55 #include <winsock2.h>
56 #else
57 #include <netinet/in.h>
58 #endif
59 #include <rx/rx.h>
60 #include <rx/xdr.h>
61 #ifdef AFS_PTHREAD_ENV
62 #include "rx/rxkad.h"
63 #endif /* AFS_PTHREAD_ENV */
64 #endif /* KERNEL */
65
66 #include <des/stats.h>
67 #include "private_data.h"
68 #define XPRT_RXKAD_CLIENT
69
70 #ifndef max
71 #define max(a,b)    ((a) < (b)? (b) : (a))
72 #endif /* max */
73
74 static struct rx_securityOps rxkad_client_ops = {
75     rxkad_Close,
76     rxkad_NewConnection,        /* every new connection */
77     rxkad_PreparePacket,        /* once per packet creation */
78     0,                          /* send packet (once per retrans.) */
79     0,
80     0,
81     0,
82     rxkad_GetResponse,          /* respond to challenge packet */
83     0,
84     rxkad_CheckPacket,          /* check data packet */
85     rxkad_DestroyConnection,
86     rxkad_GetStats,
87     0,
88     0,
89     0,
90 };
91
92 /* To minimize changes to epoch, we set this Cuid once, and everyone (including
93  * rxnull) uses it after that.  This means that the Ksession of the first
94  * authencticated connection should be a good one. */
95
96 #ifdef AFS_PTHREAD_ENV
97 /*
98  * This mutex protects the following global variables:
99  * Cuid
100  * counter
101  * rxkad_EpochWasSet
102  */
103 #include <assert.h>
104 pthread_mutex_t rxkad_client_uid_mutex;
105 #define LOCK_CUID assert(pthread_mutex_lock(&rxkad_client_uid_mutex)==0)
106 #define UNLOCK_CUID assert(pthread_mutex_unlock(&rxkad_client_uid_mutex)==0)
107 #else
108 #define LOCK_CUID
109 #define UNLOCK_CUID
110 #endif /* AFS_PTHREAD_ENV */
111
112 static afs_int32 Cuid[2];       /* set once and shared by all */
113 int rxkad_EpochWasSet = 0;      /* TRUE => we called rx_SetEpoch */
114
115 /* allocate a new connetion ID in place */
116 int
117 rxkad_AllocCID(struct rx_securityClass *aobj, struct rx_connection *aconn)
118 {
119     struct rxkad_cprivate *tcp;
120     struct rxkad_cidgen tgen;
121     static afs_int32 counter = 0;       /* not used anymore */
122
123     LOCK_CUID;
124     if (Cuid[0] == 0) {
125         afs_uint32 xor[2];
126         tgen.ipAddr = rxi_getaddr();    /* comes back in net order */
127         clock_GetTime(&tgen.time);      /* changes time1 and time2 */
128         tgen.time.sec = htonl(tgen.time.sec);
129         tgen.time.usec = htonl(tgen.time.usec);
130         tgen.counter = htonl(counter);
131         counter++;
132 #ifdef KERNEL
133         tgen.random1 = afs_random() & 0x7fffffff;       /* was "80000" */
134         tgen.random2 = afs_random() & 0x7fffffff;       /* was "htonl(100)" */
135 #else
136         tgen.random1 = htonl(getpid());
137         tgen.random2 = htonl(100);
138 #endif
139         if (aobj) {
140             /* block is ready for encryption with session key, let's go for it. */
141             tcp = (struct rxkad_cprivate *)aobj->privateData;
142             memcpy((void *)xor, (void *)tcp->ivec, 2 * sizeof(afs_int32));
143             fc_cbc_encrypt((char *)&tgen, (char *)&tgen, sizeof(tgen),
144                            tcp->keysched, xor, ENCRYPT);
145         } else {
146             /* Create a session key so that we can encrypt it */
147
148         }
149         memcpy((void *)Cuid,
150                ((char *)&tgen) + sizeof(tgen) - ENCRYPTIONBLOCKSIZE,
151                ENCRYPTIONBLOCKSIZE);
152         Cuid[0] = (Cuid[0] & ~0x40000000) | 0x80000000;
153         Cuid[1] &= RX_CIDMASK;
154         rx_SetEpoch(Cuid[0]);   /* for future rxnull connections */
155         rxkad_EpochWasSet++;
156     }
157
158     if (!aconn) {
159         UNLOCK_CUID;
160         return 0;
161     }
162     aconn->epoch = Cuid[0];
163     aconn->cid = Cuid[1];
164     Cuid[1] += 1 << RX_CIDSHIFT;
165     UNLOCK_CUID;
166     return 0;
167 }
168
169 /* Allocate a new client security object.  Called with the encryption level,
170  * the session key and the ticket for the other side obtained from the
171  * AuthServer.  Refers to export control to determine level. */
172
173 struct rx_securityClass *
174 rxkad_NewClientSecurityObject(rxkad_level level,
175                               struct ktc_encryptionKey *sessionkey,
176                               afs_int32 kvno, int ticketLen, char *ticket)
177 {
178     struct rx_securityClass *tsc;
179     struct rxkad_cprivate *tcp;
180     int code;
181     int size;
182
183     size = sizeof(struct rx_securityClass);
184     tsc = (struct rx_securityClass *)rxi_Alloc(size);
185     memset((void *)tsc, 0, size);
186     tsc->refCount = 1;          /* caller gets one for free */
187     tsc->ops = &rxkad_client_ops;
188
189     size = sizeof(struct rxkad_cprivate);
190     tcp = (struct rxkad_cprivate *)rxi_Alloc(size);
191     memset((void *)tcp, 0, size);
192     tsc->privateData = (char *)tcp;
193     tcp->type |= rxkad_client;
194     tcp->level = level;
195     code = fc_keysched(sessionkey, tcp->keysched);
196     if (code) {
197         rxi_Free(tcp, sizeof(struct rxkad_cprivate));
198         rxi_Free(tsc, sizeof(struct rx_securityClass));
199         return 0;               /* bad key */
200     }
201     memcpy((void *)tcp->ivec, (void *)sessionkey, sizeof(tcp->ivec));
202     tcp->kvno = kvno;           /* key version number */
203     tcp->ticketLen = ticketLen; /* length of ticket */
204     if (tcp->ticketLen > MAXKTCTICKETLEN) {
205         rxi_Free(tcp, sizeof(struct rxkad_cprivate));
206         rxi_Free(tsc, sizeof(struct rx_securityClass));
207         return 0;               /* bad key */
208     }
209     memcpy(tcp->ticket, ticket, ticketLen);
210
211     INC_RXKAD_STATS(clientObjects);
212     return tsc;
213 }
214
215 /* client: respond to a challenge packet */
216
217 int
218 rxkad_GetResponse(struct rx_securityClass *aobj, struct rx_connection *aconn,
219                   struct rx_packet *apacket)
220 {
221     struct rxkad_cprivate *tcp;
222     char *tp;
223     int v2;                     /* whether server is old style or v2 */
224     afs_int32 challengeID;
225     rxkad_level level;
226     char *response;
227     int responseSize, missing;
228     struct rxkad_v2ChallengeResponse r_v2;
229     struct rxkad_oldChallengeResponse r_old;
230
231     tcp = (struct rxkad_cprivate *)aobj->privateData;
232
233     if (!(tcp->type & rxkad_client))
234         return RXKADINCONSISTENCY;
235
236     v2 = (rx_Contiguous(apacket) > sizeof(struct rxkad_oldChallenge));
237     tp = rx_DataOf(apacket);
238
239     if (v2) {                   /* v2 challenge */
240         struct rxkad_v2Challenge *c_v2;
241         if (rx_GetDataSize(apacket) < sizeof(struct rxkad_v2Challenge))
242             return RXKADPACKETSHORT;
243         c_v2 = (struct rxkad_v2Challenge *)tp;
244         challengeID = ntohl(c_v2->challengeID);
245         level = ntohl(c_v2->level);
246     } else {                    /* old format challenge */
247         struct rxkad_oldChallenge *c_old;
248         if (rx_GetDataSize(apacket) < sizeof(struct rxkad_oldChallenge))
249             return RXKADPACKETSHORT;
250         c_old = (struct rxkad_oldChallenge *)tp;
251         challengeID = ntohl(c_old->challengeID);
252         level = ntohl(c_old->level);
253     }
254
255     if (level > tcp->level)
256         return RXKADLEVELFAIL;
257     INC_RXKAD_STATS(challenges[rxkad_LevelIndex(tcp->level)]);
258     if (v2) {
259         int i;
260         afs_uint32 xor[2];
261         memset((void *)&r_v2, 0, sizeof(r_v2));
262         r_v2.version = htonl(RXKAD_CHALLENGE_PROTOCOL_VERSION);
263         r_v2.spare = 0;
264         (void)rxkad_SetupEndpoint(aconn, &r_v2.encrypted.endpoint);
265         (void)rxi_GetCallNumberVector(aconn, r_v2.encrypted.callNumbers);
266         for (i = 0; i < RX_MAXCALLS; i++) {
267             if (r_v2.encrypted.callNumbers[i] < 0)
268                 return RXKADINCONSISTENCY;
269             r_v2.encrypted.callNumbers[i] =
270                 htonl(r_v2.encrypted.callNumbers[i]);
271         }
272         r_v2.encrypted.incChallengeID = htonl(challengeID + 1);
273         r_v2.encrypted.level = htonl((afs_int32) tcp->level);
274         r_v2.kvno = htonl(tcp->kvno);
275         r_v2.ticketLen = htonl(tcp->ticketLen);
276         r_v2.encrypted.endpoint.cksum = rxkad_CksumChallengeResponse(&r_v2);
277         memcpy((void *)xor, (void *)tcp->ivec, 2 * sizeof(afs_int32));
278         fc_cbc_encrypt(&r_v2.encrypted, &r_v2.encrypted,
279                        sizeof(r_v2.encrypted), tcp->keysched, xor, ENCRYPT);
280         response = (char *)&r_v2;
281         responseSize = sizeof(r_v2);
282     } else {
283         memset((void *)&r_old, 0, sizeof(r_old));
284         r_old.encrypted.incChallengeID = htonl(challengeID + 1);
285         r_old.encrypted.level = htonl((afs_int32) tcp->level);
286         r_old.kvno = htonl(tcp->kvno);
287         r_old.ticketLen = htonl(tcp->ticketLen);
288         fc_ecb_encrypt(&r_old.encrypted, &r_old.encrypted, tcp->keysched,
289                        ENCRYPT);
290         response = (char *)&r_old;
291         responseSize = sizeof(r_old);
292     }
293
294     if (RX_MAX_PACKET_DATA_SIZE < responseSize + tcp->ticketLen)
295         return RXKADPACKETSHORT;        /* not enough space */
296
297     rx_computelen(apacket, missing);
298     missing = responseSize + tcp->ticketLen - missing;
299     if (missing > 0)
300         if (rxi_AllocDataBuf(apacket, missing, RX_PACKET_CLASS_SEND) > 0)
301             return RXKADPACKETSHORT;    /* not enough space */
302
303     /* copy response and ticket into packet */
304     rx_packetwrite(apacket, 0, responseSize, response);
305     rx_packetwrite(apacket, responseSize, tcp->ticketLen, tcp->ticket);
306
307     rx_SetDataSize(apacket, responseSize + tcp->ticketLen);
308     return 0;
309 }
310
311 void
312 rxkad_ResetState(void)
313 {
314     LOCK_CUID;
315     Cuid[0] = 0;
316     rxkad_EpochWasSet = 0;
317     UNLOCK_CUID;
318 }