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