src/auth/authcon.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 #include <afsconfig.h>
  11 #include <afs/param.h>
  12 #include <afs/stds.h>
  13
  14 #include <roken.h>
  15
  16 #ifdef IGNORE_SOME_GCC_WARNINGS
  17 # pragma GCC diagnostic warning "-Wdeprecated-declarations"
  18 #endif
  19
  20 #define HC_DEPRECATED
  21 #include <hcrypto/des.h>
  22
  23 #include <rx/rxkad.h>
  24 #include <rx/rx.h>
  25
  26 #include <afs/pthread_glock.h>
  27
  28 #include "cellconfig.h"
  29 #include "keys.h"
  30 #include "ktc.h"
  31 #include "auth.h"
  32
  33 /* return a null security object if nothing else can be done */
  34 static afs_int32
  35 QuickAuth(struct rx_securityClass **astr, afs_int32 *aindex)
  36 {
  37     struct rx_securityClass *tc;
  38     tc = rxnull_NewClientSecurityObject();
  39     *astr = tc;
  40     *aindex = RX_SECIDX_NULL;
  41     return 0;
  42 }
  43
  44 #if !defined(UKERNEL)
  45 /* Return an appropriate security class and index */
  46 afs_int32
  47 afsconf_ServerAuth(void *arock,
  48                    struct rx_securityClass **astr,
  49                    afs_int32 *aindex)
  50 {
  51     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
  52     struct rx_securityClass *tclass;
  53
  54     LOCK_GLOBAL_MUTEX;
  55     tclass = (struct rx_securityClass *)
  56         rxkad_NewServerSecurityObject(0, adir, afsconf_GetKey, NULL);
  57     if (tclass) {
  58         *astr = tclass;
  59         *aindex = RX_SECIDX_KAD;
  60         UNLOCK_GLOBAL_MUTEX;
  61         return 0;
  62     } else {
  63         UNLOCK_GLOBAL_MUTEX;
  64         return 2;
  65     }
  66 }
  67 #endif /* !defined(UKERNEL) */
  68
  69 static afs_int32
  70 GenericAuth(struct afsconf_dir *adir,
  71             struct rx_securityClass **astr,
  72             afs_int32 *aindex,
  73             rxkad_level enclevel)
  74 {
  75     char tbuffer[256];
  76     struct ktc_encryptionKey key, session;
  77     struct rx_securityClass *tclass;
  78     afs_int32 kvno;
  79     afs_int32 ticketLen;
  80     afs_int32 code;
  81
  82     /* first, find the right key and kvno to use */
  83     code = afsconf_GetLatestKey(adir, &kvno, &key);
  84     if (code) {
  85         return QuickAuth(astr, aindex);
  86     }
  87
  88     /* next create random session key, using key for seed to good random */
  89     DES_init_random_number_generator((DES_cblock *) &key);
  90     code = DES_new_random_key((DES_cblock *) &session);
  91     if (code) {
  92         return QuickAuth(astr, aindex);
  93     }
  94
  95     /* now create the actual ticket */
  96     ticketLen = sizeof(tbuffer);
  97     memset(tbuffer, '\0', sizeof(tbuffer));
  98     code =
  99         tkt_MakeTicket(tbuffer, &ticketLen, &key, AUTH_SUPERUSER, "", "", 0,
 100                        0xffffffff, &session, 0, "afs", "");
 101     /* parms were buffer, ticketlen, key to seal ticket with, principal
 102      * name, instance and cell, start time, end time, session key to seal
 103      * in ticket, inet host, server name and server instance */
 104     if (code) {
 105         return QuickAuth(astr, aindex);
 106     }
 107
 108     /* Next, we have ticket, kvno and session key, authenticate the connection.
 109      * We use a magic # instead of a constant because of basic compilation
 110      * order when compiling the system from scratch (rx/rxkad.h isn't installed
 111      * yet). */
 112     tclass = (struct rx_securityClass *)
 113         rxkad_NewClientSecurityObject(enclevel, &session, kvno, ticketLen,
 114                                       tbuffer);
 115     *astr = tclass;
 116     *aindex = RX_SECIDX_KAD;
 117     return 0;
 118 }
 119
 120 /* build a fake ticket for 'afs' using keys from adir, returning an
 121  * appropriate security class and index
 122  */
 123 afs_int32
 124 afsconf_ClientAuth(void *arock, struct rx_securityClass ** astr,
 125                    afs_int32 * aindex)
 126 {
 127     struct afsconf_dir * adir = (struct afsconf_dir *) arock;
 128     afs_int32 rc;
 129
 130     LOCK_GLOBAL_MUTEX;
 131     rc = GenericAuth(adir, astr, aindex, rxkad_clear);
 132     UNLOCK_GLOBAL_MUTEX;
 133     return rc;
 134 }
 135
 136 /* build a fake ticket for 'afs' using keys from adir, returning an
 137  * appropriate security class and index.  This one, unlike the above,
 138  * tells rxkad to encrypt the data, too.
 139  */
 140 afs_int32
 141 afsconf_ClientAuthSecure(void *arock,
 142                          struct rx_securityClass **astr,
 143                          afs_int32 *aindex)
 144 {
 145     struct afsconf_dir *adir = (struct afsconf_dir *) arock;
 146     afs_int32 rc;
 147
 148     LOCK_GLOBAL_MUTEX;
 149     rc = GenericAuth(adir, astr, aindex, rxkad_crypt);
 150     UNLOCK_GLOBAL_MUTEX;
 151     return rc;
 152 }
 153
 154 /*!
 155  * Build a security class from the user's current tokens
 156  *
 157  * This function constructs an RX security class from a user's current
 158  * tokens.
 159  *
 160  * @param[in] info      The cell information structure
 161  * @param[in] flags     Security flags describing the desired mechanism
 162  * @param[out] sc       The selected security class
 163  * @param[out] scIndex  The index of the selected class
 164  * @parma[out] expires  The expiry time of the tokens used to build the class
 165  *
 166  * Only the AFSCONF_SECOPTS_ALWAYSENCRYPT flag will modify the behaviour of
 167  * this function - it determines whether a cleartext, or encrypting, security
 168  * class is provided.
 169  *
 170  * @return
 171  *     0 on success, non-zero on failure. An error code of
 172  *     AFSCONF_NO_SECURITY_CLASS indicates that were were unable to build a
 173  *     security class using the selected tokens.
 174  */
 175
 176 afs_int32
 177 afsconf_ClientAuthToken(struct afsconf_cell *info,
 178                         afsconf_secflags flags,
 179                         struct rx_securityClass **sc,
 180                         afs_int32 *scIndex,
 181                         time_t *expires)
 182 {
 183     struct ktc_setTokenData *tokenSet = NULL;
 184     struct ktc_token ttoken;
 185     int encryptLevel;
 186     afs_int32 code;
 187
 188     *sc = NULL;
 189     *scIndex = RX_SECIDX_NULL;
 190
 191     code = ktc_GetTokenEx(info->name, &tokenSet);
 192     if (code)
 193         goto out;
 194
 195     code = token_extractRxkad(tokenSet, &ttoken, NULL, NULL);
 196     if (code == 0) {
 197         /* XXX - We should think about how to handle this */
 198         if (ttoken.kvno < 0 || ttoken.kvno > 256) {
 199              fprintf(stderr,
 200                     "funny kvno (%d) in ticket, proceeding\n",
 201                     ttoken.kvno);
 202         }
 203         if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
 204             encryptLevel = rxkad_crypt;
 205         else
 206             encryptLevel = rxkad_clear;
 207         *sc = rxkad_NewClientSecurityObject(encryptLevel,
 208                                             &ttoken.sessionKey,
 209                                             ttoken.kvno,
 210                                             ttoken.ticketLen,
 211                                             ttoken.ticket);
 212         *scIndex = RX_SECIDX_KAD;
 213         if (expires)
 214             *expires = ttoken.endTime;
 215     }
 216
 217 out:
 218     token_FreeSet(&tokenSet);
 219
 220     if (*sc == NULL)
 221         return AFSCONF_NO_SECURITY_CLASS;
 222
 223     return code;
 224 }
 225
 226 /*!
 227  * Set the security flags to be used for a particular configuration
 228  */
 229 void
 230 afsconf_SetSecurityFlags(struct afsconf_dir *dir,
 231                          afsconf_secflags flags)
 232 {
 233     dir->securityFlags = flags;
 234 }
 235
 236 /*!
 237  * Build a set of security classes suitable for a server accepting
 238  * incoming connections
 239  */
 240 #if !defined(UKERNEL)
 241 void
 242 afsconf_BuildServerSecurityObjects(void *rock,
 243                                    struct rx_securityClass ***classes,
 244                                    afs_int32 *numClasses)
 245 {
 246     struct afsconf_dir *dir = rock;
 247
 248     if (dir->securityFlags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
 249         *numClasses = 4;
 250     else
 251         *numClasses = 3;
 252
 253     *classes = calloc(*numClasses, sizeof(**classes));
 254
 255     (*classes)[0] = rxnull_NewServerSecurityObject();
 256     (*classes)[1] = NULL;
 257     (*classes)[2] = rxkad_NewServerSecurityObject(0, dir,
 258                                                   afsconf_GetKey, NULL);
 259
 260     if (dir->securityFlags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
 261         (*classes)[3] = rxkad_NewServerSecurityObject(rxkad_crypt, dir,
 262                                                       afsconf_GetKey, NULL);
 263 }
 264 #endif
 265
 266 /*!
 267  * Pick a security class to use for an outgoing connection
 268  *
 269  * This function selects an RX security class to use for an outgoing
 270  * connection, based on the set of security flags provided.
 271  *
 272  * @param[in] dir
 273  *      The configuration directory structure for this cell. If NULL,
 274  *      no classes requiring local configuration will be returned.
 275  * @param[in] flags
 276  *      A set of flags to determine the properties of the security class which
 277  *      is selected
 278  *      - AFSCONF_SECOPTS_NOAUTH - return an anonymous secirty class
 279  *      - AFSCONF_SECOPTS_LOCALAUTH - use classes which have local key
 280  *              material available.
 281  *      - AFSCONF_SECOPTS_ALWAYSENCRYPT - use classes in encrypting, rather
 282  *              than authentication or integrity modes.
 283  *      - AFSCONF_SECOPTS_FALLBACK_NULL - if no suitable class can be found,
 284  *              then fallback to the rxnull security class.
 285  * @param[in] info
 286  *      The cell information structure for the current cell. If this is NULL,
 287  *      then use a version locally obtained using the cellName.
 288  * @param[in] cellName
 289  *      The cellName to use when obtaining cell information (may be NULL if
 290  *      info is specified)
 291  * @param[out] sc
 292  *      The selected security class
 293  * @param[out] scIndex
 294  *      The index of the selected security class
 295  * @param[out] expires
 296  *      The expiry time of the tokens used to construct the class. Will be
 297  *      NEVER_DATE if the class has an unlimited lifetime. If NULL, the
 298  *      function won't store the expiry date.
 299  *
 300  * @return
 301  *      Returns 0 on success, or a com_err error code on failure.
 302  */
 303 afs_int32
 304 afsconf_PickClientSecObj(struct afsconf_dir *dir, afsconf_secflags flags,
 305                          struct afsconf_cell *info,
 306                          char *cellName, struct rx_securityClass **sc,
 307                          afs_int32 *scIndex, time_t *expires) {
 308     struct afsconf_cell localInfo;
 309     afs_int32 code = 0;
 310
 311     *sc = NULL;
 312     *scIndex = RX_SECIDX_NULL;
 313     if (expires)
 314         *expires = 0;
 315
 316     if ( !(flags & AFSCONF_SECOPTS_NOAUTH) ) {
 317         if (!dir)
 318             return AFSCONF_NOCELLDB;
 319
 320         if (flags & AFSCONF_SECOPTS_LOCALAUTH) {
 321             if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
 322                 code = afsconf_ClientAuthSecure(dir, sc, scIndex);
 323             else
 324                 code = afsconf_ClientAuth(dir, sc, scIndex);
 325
 326             if (code)
 327                 goto out;
 328
 329             /* The afsconf_ClientAuth functions will fall back to giving
 330              * a rxnull object, which we don't want if localauth has been
 331              * explicitly requested. Check for this, and bail out if we
 332              * get one. Note that this leaks a security object at present
 333              */
 334             if (*scIndex == RX_SECIDX_NULL) {
 335                 sc = NULL;
 336                 code = AFSCONF_NOTFOUND;
 337                 goto out;
 338             }
 339
 340             if (expires)
 341                 *expires = NEVERDATE;
 342         } else {
 343             if (info == NULL) {
 344                 code = afsconf_GetCellInfo(dir, cellName, NULL, &localInfo);
 345                 if (code)
 346                     goto out;
 347                 info = &localInfo;
 348             }
 349
 350             code = afsconf_ClientAuthToken(info, flags, sc, scIndex, expires);
 351             if (code && !(flags & AFSCONF_SECOPTS_FALLBACK_NULL))
 352                 goto out;
 353
 354             /* If we didn't get a token, we'll just run anonymously */
 355             code = 0;
 356         }
 357     }
 358     if (*sc == NULL) {
 359         *sc = rxnull_NewClientSecurityObject();
 360         *scIndex = RX_SECIDX_NULL;
 361         if (expires)
 362             *expires = NEVERDATE;
 363     }
 364
 365 out:
 366     return code;
 367 }