8eed980a4bb8f7f2b8153c116ad8014927a0ae83
[openafs.git] / src / rxkad / rxkad_common.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.  Routines used by both client and servers. */
11
12 #include <afsconfig.h>
13 #include <afs/param.h>
14 #include <afs/stds.h>
15
16 #ifdef AFS_SUN59_ENV
17 #include <sys/time_impl.h>
18 #endif
19
20 #define INCLUDE_RXKAD_PRIVATE_DECLS
21
22 #ifdef KERNEL
23 #ifndef UKERNEL
24 #include "afs/afs_osi.h"
25 #if defined(AFS_AIX_ENV) || defined(AFS_AUX_ENV) || defined(AFS_SUN5_ENV)
26 #include "h/systm.h"
27 #endif
28 #if defined(AFS_DARWIN_ENV) || defined(AFS_OBSD_ENV)
29 #include "h/kernel.h"
30 #endif
31 #include "h/types.h"
32 #include "h/time.h"
33 #else /* !UKERNEL */
34 #include "afs/sysincludes.h"
35 #include "afsincludes.h"
36 #endif /* !UKERNEL */
37 #else /* KERNEL */
38 #include <roken.h>
39 #if defined(AFS_NT40_ENV) && defined(AFS_PTHREAD_ENV)
40 #define RXKAD_STATS_DECLSPEC __declspec(dllexport)
41 #endif
42 #include <afs/afsutil.h>
43 #endif /* KERNEL */
44
45 #include <rx/rx.h>
46 #include <rx/xdr.h>
47
48 #include "stats.h"
49 #include "private_data.h"
50 #define XPRT_RXKAD_COMMON
51
52 #ifndef afs_max
53 #define afs_max(a,b)    ((a) < (b)? (b) : (a))
54 #endif /* afs_max */
55
56 #ifndef KERNEL
57 #define osi_Time() time(0)
58 #endif
59 /* variable initialization for the benefit of darwin compiler; if it causes
60    problems elsewhere, conditionalize for darwin or fc_test compile breaks */
61 #ifdef AFS_PTHREAD_ENV
62 struct rxkad_global_stats rxkad_global_stats = { 0 };
63 pthread_mutex_t rxkad_global_stats_lock;
64 pthread_key_t rxkad_stats_key;
65 #else /* AFS_PTHREAD_ENV */
66 struct rxkad_stats rxkad_stats = { { 0 } };
67 #endif /* AFS_PTHREAD_ENV */
68
69 #ifdef AFS_PTHREAD_ENV
70 /* Pthread initialisation */
71 static pthread_once_t rxkad_once_init = PTHREAD_ONCE_INIT;
72 extern pthread_mutex_t rxkad_client_uid_mutex;
73 extern pthread_mutex_t rxkad_random_mutex;
74
75 static void
76 rxkad_global_stats_init(void)
77 {
78     osi_Assert(pthread_mutex_init(&rxkad_global_stats_lock, (const pthread_mutexattr_t *)0) == 0);
79     osi_Assert(pthread_key_create(&rxkad_stats_key, NULL) == 0);
80     memset(&rxkad_global_stats, 0, sizeof(rxkad_global_stats));
81 }
82
83 static void
84 rxkad_InitPthread(void) {
85     MUTEX_INIT(&rxkad_client_uid_mutex, "uid", MUTEX_DEFAULT, 0);
86     MUTEX_INIT(&rxkad_random_mutex, "rxkad random", MUTEX_DEFAULT, 0);
87
88     rxkad_global_stats_init();
89 }
90
91 void
92 rxkad_Init(void) {
93     osi_Assert(pthread_once(&rxkad_once_init, rxkad_InitPthread) == 0);
94 }
95
96 /* rxkad_stats related stuff */
97
98 /*
99  * Macro to insert an element at the tail of a doubly linked list
100  */
101 #define DLL_INSERT_TAIL(ptr,head,tail,next,prev) \
102     do {                                         \
103         (ptr)->next = NULL;                      \
104         (ptr)->prev = (tail);                    \
105         (tail) = (ptr);                          \
106         if ((ptr)->prev)                         \
107             (ptr)->prev->next = (ptr);           \
108         else                                     \
109             (head) = (ptr);                      \
110         osi_Assert((head) && ((head)->prev == NULL)); \
111     } while(0)
112
113 rxkad_stats_t *
114 rxkad_thr_stats_init(void) {
115     rxkad_stats_t * rxkad_stats;
116     rxkad_stats = (rxkad_stats_t *)malloc(sizeof(rxkad_stats_t));
117     osi_Assert(rxkad_stats != NULL && pthread_setspecific(rxkad_stats_key,rxkad_stats) == 0);
118     memset(rxkad_stats,0,sizeof(rxkad_stats_t));
119     RXKAD_GLOBAL_STATS_LOCK;
120     DLL_INSERT_TAIL(rxkad_stats, rxkad_global_stats.first, rxkad_global_stats.last, next, prev);
121     RXKAD_GLOBAL_STATS_UNLOCK;
122     return rxkad_stats;
123 }
124
125 int rxkad_stats_agg(rxkad_stats_t * rxkad_stats) {
126     rxkad_stats_t * thr_stats;
127     osi_Assert(rxkad_stats != NULL);
128     memset(rxkad_stats, 0, sizeof(rxkad_stats_t));
129     RXKAD_GLOBAL_STATS_LOCK;
130     for (thr_stats = rxkad_global_stats.first; thr_stats != NULL; thr_stats = thr_stats->next) {
131         rxkad_stats->connections[0] += thr_stats->connections[0];
132         rxkad_stats->connections[1] += thr_stats->connections[1];
133         rxkad_stats->connections[2] += thr_stats->connections[2];
134         rxkad_stats->destroyObject += thr_stats->destroyObject;
135         rxkad_stats->destroyClient += thr_stats->destroyClient;
136         rxkad_stats->destroyUnused += thr_stats->destroyUnused;
137         rxkad_stats->destroyUnauth += thr_stats->destroyUnauth;
138         rxkad_stats->destroyConn[0] += thr_stats->destroyConn[0];
139         rxkad_stats->destroyConn[1] += thr_stats->destroyConn[1];
140         rxkad_stats->destroyConn[2] += thr_stats->destroyConn[2];
141         rxkad_stats->expired += thr_stats->expired;
142         rxkad_stats->challengesSent += thr_stats->challengesSent;
143         rxkad_stats->challenges[0] += thr_stats->challenges[0];
144         rxkad_stats->challenges[1] += thr_stats->challenges[1];
145         rxkad_stats->challenges[2] += thr_stats->challenges[2];
146         rxkad_stats->responses[0] += thr_stats->responses[0];
147         rxkad_stats->responses[1] += thr_stats->responses[1];
148         rxkad_stats->responses[2] += thr_stats->responses[2];
149         rxkad_stats->preparePackets[0] += thr_stats->preparePackets[0];
150         rxkad_stats->preparePackets[1] += thr_stats->preparePackets[1];
151         rxkad_stats->preparePackets[2] += thr_stats->preparePackets[2];
152         rxkad_stats->preparePackets[3] += thr_stats->preparePackets[3];
153         rxkad_stats->preparePackets[4] += thr_stats->preparePackets[4];
154         rxkad_stats->preparePackets[5] += thr_stats->preparePackets[5];
155         rxkad_stats->checkPackets[0] += thr_stats->checkPackets[0];
156         rxkad_stats->checkPackets[1] += thr_stats->checkPackets[1];
157         rxkad_stats->checkPackets[2] += thr_stats->checkPackets[2];
158         rxkad_stats->checkPackets[3] += thr_stats->checkPackets[3];
159         rxkad_stats->checkPackets[4] += thr_stats->checkPackets[4];
160         rxkad_stats->checkPackets[5] += thr_stats->checkPackets[5];
161         rxkad_stats->bytesEncrypted[0] += thr_stats->bytesEncrypted[0];
162         rxkad_stats->bytesEncrypted[1] += thr_stats->bytesEncrypted[1];
163         rxkad_stats->bytesDecrypted[0] += thr_stats->bytesDecrypted[0];
164         rxkad_stats->bytesDecrypted[1] += thr_stats->bytesDecrypted[1];
165         rxkad_stats->fc_encrypts[0] += thr_stats->fc_encrypts[0];
166         rxkad_stats->fc_encrypts[1] += thr_stats->fc_encrypts[1];
167         rxkad_stats->fc_key_scheds += thr_stats->fc_key_scheds;
168         rxkad_stats->des_encrypts[0] += thr_stats->des_encrypts[0];
169         rxkad_stats->des_encrypts[1] += thr_stats->des_encrypts[1];
170         rxkad_stats->des_key_scheds += thr_stats->des_key_scheds;
171         rxkad_stats->des_randoms += thr_stats->des_randoms;
172         rxkad_stats->clientObjects += thr_stats->clientObjects;
173         rxkad_stats->serverObjects += thr_stats->serverObjects;
174         rxkad_stats->spares[0] += thr_stats->spares[0];
175         rxkad_stats->spares[1] += thr_stats->spares[1];
176         rxkad_stats->spares[2] += thr_stats->spares[2];
177         rxkad_stats->spares[3] += thr_stats->spares[3];
178         rxkad_stats->spares[4] += thr_stats->spares[4];
179         rxkad_stats->spares[5] += thr_stats->spares[5];
180         rxkad_stats->spares[6] += thr_stats->spares[6];
181         rxkad_stats->spares[7] += thr_stats->spares[7];
182     }
183     RXKAD_GLOBAL_STATS_UNLOCK;
184     return 0;
185 }
186 #else
187 void
188 rxkad_Init(void)
189 {
190     return;
191 }
192 #endif /* AFS_PTHREAD_ENV */
193
194 /* static prototypes */
195 static afs_int32 ComputeSum(struct rx_packet *apacket,
196                             fc_KeySchedule * aschedule, afs_int32 * aivec);
197 static afs_int32 FreeObject(struct rx_securityClass *aobj);
198
199 /* this call sets up an endpoint structure, leaving it in *network* byte
200  * order so that it can be used quickly for encryption.
201  */
202 int
203 rxkad_SetupEndpoint(struct rx_connection *aconnp,
204                     struct rxkad_endpoint *aendpointp)
205 {
206     afs_int32 i;
207
208     aendpointp->cuid[0] = htonl(aconnp->epoch);
209     i = aconnp->cid & RX_CIDMASK;
210     aendpointp->cuid[1] = htonl(i);
211     aendpointp->cksum = 0;      /* used as cksum only in chal resp. */
212     aendpointp->securityIndex = htonl(aconnp->securityIndex);
213     return 0;
214 }
215
216 /* setup xor information based on session key */
217 int
218 rxkad_DeriveXORInfo(struct rx_connection *aconnp, fc_KeySchedule * aschedule,
219                     char *aivec, char *aresult)
220 {
221     struct rxkad_endpoint tendpoint;
222     afs_uint32 xor[2];
223
224     rxkad_SetupEndpoint(aconnp, &tendpoint);
225     memcpy((void *)xor, aivec, 2 * sizeof(afs_int32));
226     fc_cbc_encrypt(&tendpoint, &tendpoint, sizeof(tendpoint), *aschedule, xor,
227                    ENCRYPT);
228     memcpy(aresult,
229            ((char *)&tendpoint) + sizeof(tendpoint) - ENCRYPTIONBLOCKSIZE,
230            ENCRYPTIONBLOCKSIZE);
231     return 0;
232 }
233
234 /* rxkad_CksumChallengeResponse - computes a checksum of the components of a
235  * challenge response packet (which must be unencrypted and in network order).
236  * The endpoint.cksum field is omitted and treated as zero.  The cksum is
237  * returned in network order. */
238
239 afs_uint32
240 rxkad_CksumChallengeResponse(struct rxkad_v2ChallengeResponse * v2r)
241 {
242     int i;
243     afs_uint32 cksum;
244     u_char *cp = (u_char *) v2r;
245     afs_uint32 savedCksum = v2r->encrypted.endpoint.cksum;
246
247     v2r->encrypted.endpoint.cksum = 0;
248
249     /* this function captured from budb/db_hash.c */
250     cksum = 1000003;
251     for (i = 0; i < sizeof(*v2r); i++)
252         cksum = (*cp++) + cksum * 0x10204081;
253
254     v2r->encrypted.endpoint.cksum = savedCksum;
255     return htonl(cksum);
256 }
257
258 void
259 rxkad_SetLevel(struct rx_connection *conn, rxkad_level level)
260 {
261     if (level == rxkad_auth) {
262         rx_SetSecurityHeaderSize(conn, 4);
263         rx_SetSecurityMaxTrailerSize(conn, 4);
264     } else if (level == rxkad_crypt) {
265         rx_SetSecurityHeaderSize(conn, 8);
266         rx_SetSecurityMaxTrailerSize(conn, 8);  /* XXX was 7, but why screw with
267                                                  * unaligned accesses? */
268     }
269 }
270
271 /* returns a short integer in host byte order representing a good checksum of
272  * the packet header.
273  */
274 static afs_int32
275 ComputeSum(struct rx_packet *apacket, fc_KeySchedule * aschedule,
276            afs_int32 * aivec)
277 {
278     afs_uint32 word[2];
279     afs_uint32 t;
280
281     t = apacket->header.callNumber;
282     word[0] = htonl(t);
283     /* note that word [1] includes the channel # */
284     t = ((apacket->header.cid & 0x3) << 30)
285         | ((apacket->header.seq & 0x3fffffff));
286     word[1] = htonl(t);
287     /* XOR in the ivec from the per-endpoint encryption */
288     word[0] ^= aivec[0];
289     word[1] ^= aivec[1];
290     /* encrypts word as if it were a character string */
291     fc_ecb_encrypt(word, word, *aschedule, ENCRYPT);
292     t = ntohl(word[1]);
293     t = (t >> 16) & 0xffff;
294     if (t == 0)
295         t = 1;                  /* so that 0 means don't care */
296     return t;
297 }
298
299
300 static afs_int32
301 FreeObject(struct rx_securityClass *aobj)
302 {
303     struct rxkad_cprivate *tcp; /* both structs start w/ type field */
304
305     if (aobj->refCount > 0)
306         return 0;               /* still in use */
307     tcp = (struct rxkad_cprivate *)aobj->privateData;
308     rxi_Free(aobj, sizeof(struct rx_securityClass));
309     if (tcp->type & rxkad_client) {
310         afs_int32 psize = PDATA_SIZE(tcp->ticketLen);
311         rxi_Free(tcp, psize);
312     } else if (tcp->type & rxkad_server) {
313         rxi_Free(tcp, sizeof(struct rxkad_sprivate));
314     } else {
315         return RXKADINCONSISTENCY;
316     }                           /* unknown type */
317     INC_RXKAD_STATS(destroyObject);
318     return 0;
319 }
320
321 /* rxkad_Close - called by rx with the security class object as a parameter
322  * when a security object is to be discarded */
323
324 int
325 rxkad_Close(struct rx_securityClass *aobj)
326 {
327     afs_int32 code;
328     aobj->refCount--;
329     code = FreeObject(aobj);
330     return code;
331 }
332
333 /* either: called to (re)create a new connection. */
334
335 int
336 rxkad_NewConnection(struct rx_securityClass *aobj,
337                     struct rx_connection *aconn)
338 {
339     if (aconn->securityData)
340         return RXKADINCONSISTENCY;      /* already allocated??? */
341
342     if (rx_IsServerConn(aconn)) {
343         int size = sizeof(struct rxkad_sconn);
344         aconn->securityData = rxi_Alloc(size);
345         memset(aconn->securityData, 0, size);   /* initialize it conveniently */
346     } else {                    /* client */
347         struct rxkad_cprivate *tcp;
348         struct rxkad_cconn *tccp;
349         int size = sizeof(struct rxkad_cconn);
350         tccp = rxi_Alloc(size);
351         aconn->securityData = (char *)tccp;
352         memset(aconn->securityData, 0, size);   /* initialize it conveniently */
353         tcp = (struct rxkad_cprivate *)aobj->privateData;
354         if (!(tcp->type & rxkad_client))
355             return RXKADINCONSISTENCY;
356         rxkad_SetLevel(aconn, tcp->level);      /* set header and trailer sizes */
357         rxkad_AllocCID(aobj, aconn);    /* CHANGES cid AND epoch!!!! */
358         rxkad_DeriveXORInfo(aconn, (fc_KeySchedule *)tcp->keysched, (char *)tcp->ivec, (char *)tccp->preSeq);
359         INC_RXKAD_STATS(connections[rxkad_LevelIndex(tcp->level)]);
360     }
361
362     aobj->refCount++;           /* attached connection */
363     return 0;
364 }
365
366 /* either: called to destroy a connection. */
367
368 int
369 rxkad_DestroyConnection(struct rx_securityClass *aobj,
370                         struct rx_connection *aconn)
371 {
372     if (rx_IsServerConn(aconn)) {
373         struct rxkad_sconn *sconn;
374         struct rxkad_serverinfo *rock;
375         sconn = (struct rxkad_sconn *)aconn->securityData;
376         if (sconn) {
377             aconn->securityData = 0;
378             if (sconn->authenticated)
379                 INC_RXKAD_STATS(destroyConn[rxkad_LevelIndex(sconn->level)]);
380             else
381                 INC_RXKAD_STATS(destroyUnauth);
382             rock = sconn->rock;
383             if (rock)
384                 rxi_Free(rock, sizeof(struct rxkad_serverinfo));
385             rxi_Free(sconn, sizeof(struct rxkad_sconn));
386         } else {
387             INC_RXKAD_STATS(destroyUnused);
388         }
389     } else {                    /* client */
390         struct rxkad_cconn *cconn;
391         struct rxkad_cprivate *tcp;
392         cconn = (struct rxkad_cconn *)aconn->securityData;
393         tcp = (struct rxkad_cprivate *)aobj->privateData;
394         if (!(tcp->type & rxkad_client))
395             return RXKADINCONSISTENCY;
396         if (cconn) {
397             aconn->securityData = 0;
398             rxi_Free(cconn, sizeof(struct rxkad_cconn));
399         }
400         INC_RXKAD_STATS(destroyClient);
401     }
402     aobj->refCount--;           /* decrement connection counter */
403     if (aobj->refCount <= 0) {
404         afs_int32 code;
405         code = FreeObject(aobj);
406         if (code)
407             return code;
408     }
409     return 0;
410 }
411
412 /* either: decode packet */
413
414 int
415 rxkad_CheckPacket(struct rx_securityClass *aobj, struct rx_call *acall,
416                   struct rx_packet *apacket)
417 {
418     struct rx_connection *tconn;
419     rxkad_level level;
420     const fc_KeySchedule *schedule;
421     fc_InitializationVector *ivec;
422     int len;
423     int nlen = 0;
424     u_int word;                 /* so we get unsigned right-shift */
425     int checkCksum;
426     afs_int32 *preSeq;
427     afs_int32 code;
428
429     tconn = rx_ConnectionOf(acall);
430     len = rx_GetDataSize(apacket);
431     checkCksum = 0;             /* init */
432     if (rx_IsServerConn(tconn)) {
433         struct rxkad_sconn *sconn;
434         sconn = (struct rxkad_sconn *)tconn->securityData;
435         if (rx_GetPacketCksum(apacket) != 0)
436             sconn->cksumSeen = 1;
437         checkCksum = sconn->cksumSeen;
438         if (sconn && sconn->authenticated
439             && (osi_Time() < sconn->expirationTime)) {
440             level = sconn->level;
441             INC_RXKAD_STATS(checkPackets[rxkad_StatIndex(rxkad_server, level)]);
442             sconn->stats.packetsReceived++;
443             sconn->stats.bytesReceived += len;
444             schedule = (const fc_KeySchedule *) sconn->keysched;
445             ivec = (fc_InitializationVector *) sconn->ivec;
446         } else {
447             INC_RXKAD_STATS(expired);
448             return RXKADEXPIRED;
449         }
450         preSeq = sconn->preSeq;
451     } else {                    /* client connection */
452         struct rxkad_cconn *cconn;
453         struct rxkad_cprivate *tcp;
454         cconn = (struct rxkad_cconn *)tconn->securityData;
455         if (rx_GetPacketCksum(apacket) != 0)
456             cconn->cksumSeen = 1;
457         checkCksum = cconn->cksumSeen;
458         tcp = (struct rxkad_cprivate *)aobj->privateData;
459         if (!(tcp->type & rxkad_client))
460             return RXKADINCONSISTENCY;
461         level = tcp->level;
462         INC_RXKAD_STATS(checkPackets[rxkad_StatIndex(rxkad_client, level)]);
463         cconn->stats.packetsReceived++;
464         cconn->stats.bytesReceived += len;
465         preSeq = cconn->preSeq;
466         schedule = (const fc_KeySchedule *) tcp->keysched;
467         ivec = (fc_InitializationVector *) tcp->ivec;
468     }
469
470     if (checkCksum) {
471         code = ComputeSum(apacket, (fc_KeySchedule *)schedule, preSeq);
472         if (code != rx_GetPacketCksum(apacket))
473             return RXKADSEALEDINCON;
474     }
475
476     switch (level) {
477     case rxkad_clear:
478         return 0;               /* shouldn't happen */
479     case rxkad_auth:
480         rx_Pullup(apacket, 8);  /* the following encrypts 8 bytes only */
481         fc_ecb_encrypt(rx_DataOf(apacket), rx_DataOf(apacket), *schedule,
482                        DECRYPT);
483         break;
484     case rxkad_crypt:
485         code = rxkad_DecryptPacket(tconn, schedule, (const fc_InitializationVector *)ivec, len, apacket);
486         if (code)
487             return code;
488         break;
489     }
490     word = ntohl(rx_GetInt32(apacket, 0));      /* get first sealed word */
491     if ((word >> 16) !=
492         ((apacket->header.seq ^ apacket->header.callNumber) & 0xffff))
493         return RXKADSEALEDINCON;
494     nlen = word & 0xffff;       /* get real user data length */
495
496     /* The sealed length should be no larger than the initial length, since the
497      * reverse (round-up) occurs in ...PreparePacket */
498     if (nlen > len)
499         return RXKADDATALEN;
500     rx_SetDataSize(apacket, nlen);
501     return 0;
502 }
503
504 /* either: encode packet */
505
506 int
507 rxkad_PreparePacket(struct rx_securityClass *aobj, struct rx_call *acall,
508                     struct rx_packet *apacket)
509 {
510     struct rx_connection *tconn;
511     rxkad_level level;
512     fc_KeySchedule *schedule;
513     fc_InitializationVector *ivec;
514     int len;
515     int nlen = 0;
516     int word;
517     afs_int32 code;
518     afs_int32 *preSeq;
519
520     tconn = rx_ConnectionOf(acall);
521     len = rx_GetDataSize(apacket);
522     if (rx_IsServerConn(tconn)) {
523         struct rxkad_sconn *sconn;
524         sconn = (struct rxkad_sconn *)tconn->securityData;
525         if (sconn && sconn->authenticated
526             && (osi_Time() < sconn->expirationTime)) {
527             level = sconn->level;
528             INC_RXKAD_STATS(preparePackets[rxkad_StatIndex(rxkad_server, level)]);
529             sconn->stats.packetsSent++;
530             sconn->stats.bytesSent += len;
531             schedule = (fc_KeySchedule *) sconn->keysched;
532             ivec = (fc_InitializationVector *) sconn->ivec;
533         } else {
534             INC_RXKAD_STATS(expired);   /* this is a pretty unlikely path... */
535             return RXKADEXPIRED;
536         }
537         preSeq = sconn->preSeq;
538     } else {                    /* client connection */
539         struct rxkad_cconn *cconn;
540         struct rxkad_cprivate *tcp;
541         cconn = (struct rxkad_cconn *)tconn->securityData;
542         tcp = (struct rxkad_cprivate *)aobj->privateData;
543         if (!(tcp->type & rxkad_client))
544             return RXKADINCONSISTENCY;
545         level = tcp->level;
546         INC_RXKAD_STATS(preparePackets[rxkad_StatIndex(rxkad_client, level)]);
547         cconn->stats.packetsSent++;
548         cconn->stats.bytesSent += len;
549         preSeq = cconn->preSeq;
550         schedule = (fc_KeySchedule *) tcp->keysched;
551         ivec = (fc_InitializationVector *) tcp->ivec;
552     }
553
554     /* compute upward compatible checksum */
555     rx_SetPacketCksum(apacket, ComputeSum(apacket, schedule, preSeq));
556     if (level == rxkad_clear)
557         return 0;
558
559     len = rx_GetDataSize(apacket);
560     word = (((apacket->header.seq ^ apacket->header.callNumber)
561              & 0xffff) << 16) | (len & 0xffff);
562     rx_PutInt32(apacket, 0, htonl(word));
563
564     switch (level) {
565     case rxkad_clear:
566         return 0;               /* shouldn't happen */
567     case rxkad_auth:
568         nlen =
569             afs_max(ENCRYPTIONBLOCKSIZE,
570                     len + rx_GetSecurityHeaderSize(tconn));
571         if (nlen > (len + rx_GetSecurityHeaderSize(tconn))) {
572             rxi_RoundUpPacket(apacket,
573                               nlen - (len + rx_GetSecurityHeaderSize(tconn)));
574         }
575         rx_Pullup(apacket, 8);  /* the following encrypts 8 bytes only */
576         fc_ecb_encrypt(rx_DataOf(apacket), rx_DataOf(apacket), *schedule,
577                        ENCRYPT);
578         break;
579     case rxkad_crypt:
580         nlen = round_up_to_ebs(len + rx_GetSecurityHeaderSize(tconn));
581         if (nlen > (len + rx_GetSecurityHeaderSize(tconn))) {
582             rxi_RoundUpPacket(apacket,
583                               nlen - (len + rx_GetSecurityHeaderSize(tconn)));
584         }
585         code = rxkad_EncryptPacket(tconn, (const fc_KeySchedule *)schedule,  (const fc_InitializationVector *)ivec, nlen, apacket);
586         if (code)
587             return code;
588         break;
589     }
590     rx_SetDataSize(apacket, nlen);
591     return 0;
592 }
593
594 /* either: return connection stats */
595
596 int
597 rxkad_GetStats(struct rx_securityClass *aobj, struct rx_connection *aconn,
598                struct rx_securityObjectStats *astats)
599 {
600     astats->type = 3;
601     astats->level = ((struct rxkad_cprivate *)aobj->privateData)->level;
602     if (!aconn->securityData) {
603         astats->flags |= 1;
604         return 0;
605     }
606     if (rx_IsServerConn(aconn)) {
607         struct rxkad_sconn *sconn;
608         sconn = (struct rxkad_sconn *)aconn->securityData;
609         astats->level = sconn->level;
610         if (sconn->authenticated)
611             astats->flags |= 2;
612         if (sconn->cksumSeen)
613             astats->flags |= 8;
614         astats->expires = sconn->expirationTime;
615         astats->bytesReceived = sconn->stats.bytesReceived;
616         astats->packetsReceived = sconn->stats.packetsReceived;
617         astats->bytesSent = sconn->stats.bytesSent;
618         astats->packetsSent = sconn->stats.packetsSent;
619     } else {                    /* client connection */
620         struct rxkad_cconn *cconn;
621         cconn = (struct rxkad_cconn *)aconn->securityData;
622         if (cconn->cksumSeen)
623             astats->flags |= 8;
624         astats->bytesReceived = cconn->stats.bytesReceived;
625         astats->packetsReceived = cconn->stats.packetsReceived;
626         astats->bytesSent = cconn->stats.bytesSent;
627         astats->packetsSent = cconn->stats.packetsSent;
628     }
629     return 0;
630 }
631
632 rxkad_level
633 rxkad_StringToLevel(char *name)
634 {
635     if (strcmp(name, "clear") == 0)
636         return rxkad_clear;
637     if (strcmp(name, "auth") == 0)
638         return rxkad_auth;
639     if (strcmp(name, "crypt") == 0)
640         return rxkad_crypt;
641     return -1;
642 }
643
644 char *
645 rxkad_LevelToString(rxkad_level level)
646 {
647     if (level == rxkad_clear)
648         return "clear";
649     if (level == rxkad_auth)
650         return "auth";
651     if (level == rxkad_crypt)
652         return "crypt";
653     return "unknown";
654 }