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 }