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