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