www.project-moonshot.org Git - mech_eap.orig/blob - mech_eap/util_krb.c

   1 /*
   2  * Copyright (c) 2011, JANET(UK)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of JANET(UK) nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * Kerberos 5 helpers.
  35  */
  36
  37 #include "gssapiP_eap.h"
  38
  39 void
  40 gssEapDestroyKrbContext(krb5_context context)
  41 {
  42     if (context != NULL)
  43         krb5_free_context(context);
  44 }
  45
  46 static krb5_error_code
  47 initKrbContext(krb5_context *pKrbContext)
  48 {
  49     krb5_context krbContext;
  50     krb5_error_code code;
  51     char *defaultRealm = NULL;
  52
  53     *pKrbContext = NULL;
  54
  55     code = krb5_init_context(&krbContext);
  56     if (code != 0)
  57         goto cleanup;
  58
  59     krb5_appdefault_string(krbContext, "eap_gss",
  60                            NULL, "default_realm", "", &defaultRealm);
  61
  62     if (defaultRealm != NULL && defaultRealm[0] != '\0') {
  63         code = krb5_set_default_realm(krbContext, defaultRealm);
  64         if (code != 0)
  65             goto cleanup;
  66     }
  67
  68     *pKrbContext = krbContext;
  69
  70 cleanup:
  71     krb5_free_default_realm(krbContext, defaultRealm);
  72
  73     if (code != 0 && krbContext != NULL)
  74         krb5_free_context(krbContext);
  75
  76     return code;
  77 }
  78
  79 OM_uint32
  80 gssEapKerberosInit(OM_uint32 *minor, krb5_context *context)
  81 {
  82     struct gss_eap_thread_local_data *tld;
  83
  84     *minor = 0;
  85
  86     tld = gssEapGetThreadLocalData();
  87     if (tld != NULL) {
  88         *context = tld->krbContext;
  89         if (*context == NULL) {
  90             *minor = initKrbContext(context);
  91             if (*minor == 0)
  92                 tld->krbContext = *context;
  93         }
  94     }
  95     return *minor == 0 ? GSS_S_COMPLETE : GSS_S_FAILURE;
  96 }
  97
  98 /*
  99  * Derive a key K for RFC 4121 use by using the following
 100  * derivation function (based on RFC 4402);
 101  *
 102  * KMSK = random-to-key(MSK)
 103  * Tn = pseudo-random(KMSK, n || "rfc4121-gss-eap")
 104  * L = output key size
 105  * K = truncate(L, T1 || T2 || .. || Tn)
 106  */
 107 OM_uint32
 108 gssEapDeriveRfc3961Key(OM_uint32 *minor,
 109                        const unsigned char *inputKey,
 110                        size_t inputKeyLength,
 111                        krb5_enctype encryptionType,
 112                        krb5_keyblock *pKey)
 113 {
 114     krb5_context krbContext;
 115 #ifndef HAVE_HEIMDAL_VERSION
 116     krb5_data data;
 117 #endif
 118     krb5_data ns, t, prfOut;
 119     krb5_keyblock kd;
 120     krb5_error_code code;
 121     size_t randomLength, keyLength, prfLength;
 122     unsigned char constant[4 + sizeof("rfc4121-gss-eap") - 1], *p;
 123     ssize_t i, remain;
 124
 125     GSSEAP_ASSERT(encryptionType != ENCTYPE_NULL);
 126
 127     memset(pKey, 0, sizeof(*pKey));
 128
 129     GSSEAP_KRB_INIT(&krbContext);
 130
 131     KRB_KEY_INIT(&kd);
 132     KRB_KEY_TYPE(&kd) = encryptionType;
 133
 134     t.data = NULL;
 135     t.length = 0;
 136
 137     prfOut.data = NULL;
 138     prfOut.length = 0;
 139
 140     code = krb5_c_keylengths(krbContext, encryptionType,
 141                              &randomLength, &keyLength);
 142     if (code != 0)
 143         goto cleanup;
 144
 145     KRB_KEY_DATA(&kd) = GSSEAP_MALLOC(keyLength);
 146     if (KRB_KEY_DATA(&kd) == NULL) {
 147         code = ENOMEM;
 148         goto cleanup;
 149     }
 150     KRB_KEY_LENGTH(&kd) = keyLength;
 151
 152     /* Convert MSK into a Kerberos key */
 153 #ifdef HAVE_HEIMDAL_VERSION
 154     code = krb5_random_to_key(krbContext, encryptionType, inputKey,
 155                               MIN(inputKeyLength, randomLength), &kd);
 156 #else
 157     data.length = MIN(inputKeyLength, randomLength);
 158     data.data = (char *)inputKey;
 159
 160     code = krb5_c_random_to_key(krbContext, encryptionType, &data, &kd);
 161 #endif
 162     if (code != 0)
 163         goto cleanup;
 164
 165     memset(&constant[0], 0, 4);
 166     memcpy(&constant[4], "rfc4121-gss-eap", sizeof("rfc4121-gss-eap") - 1);
 167
 168     ns.length = sizeof(constant);
 169     ns.data = (char *)constant;
 170
 171     /* Plug derivation constant and key into PRF */
 172     code = krb5_c_prf_length(krbContext, encryptionType, &prfLength);
 173     if (code != 0)
 174         goto cleanup;
 175
 176     t.length = prfLength;
 177     t.data = GSSEAP_MALLOC(t.length);
 178     if (t.data == NULL) {
 179         code = ENOMEM;
 180         goto cleanup;
 181     }
 182
 183     prfOut.length = randomLength;
 184     prfOut.data = GSSEAP_MALLOC(prfOut.length);
 185     if (prfOut.data == NULL) {
 186         code = ENOMEM;
 187         goto cleanup;
 188     }
 189
 190     for (i = 0, p = (unsigned char *)prfOut.data, remain = randomLength;
 191          remain > 0;
 192          p += t.length, remain -= t.length, i++)
 193     {
 194         store_uint32_be(i, ns.data);
 195
 196         code = krb5_c_prf(krbContext, &kd, &ns, &t);
 197         if (code != 0)
 198             goto cleanup;
 199
 200         memcpy(p, t.data, MIN(t.length, remain));
 201      }
 202
 203     /* Finally, convert PRF output into a new key which we will return */
 204 #ifdef HAVE_HEIMDAL_VERSION
 205     code = krb5_random_to_key(krbContext, encryptionType,
 206                               prfOut.data, prfOut.length, &kd);
 207 #else
 208     code = krb5_c_random_to_key(krbContext, encryptionType, &prfOut, &kd);
 209 #endif
 210     if (code != 0)
 211         goto cleanup;
 212
 213     *pKey = kd;
 214     KRB_KEY_DATA(&kd) = NULL;
 215
 216 cleanup:
 217     if (KRB_KEY_DATA(&kd) != NULL) {
 218         memset(KRB_KEY_DATA(&kd), 0, KRB_KEY_LENGTH(&kd));
 219         GSSEAP_FREE(KRB_KEY_DATA(&kd));
 220     }
 221     if (t.data != NULL) {
 222         memset(t.data, 0, t.length);
 223         GSSEAP_FREE(t.data);
 224     }
 225     if (prfOut.data != NULL) {
 226         memset(prfOut.data, 0, prfOut.length);
 227         GSSEAP_FREE(prfOut.data);
 228     }
 229     *minor = code;
 230     return (code == 0) ? GSS_S_COMPLETE : GSS_S_FAILURE;
 231 }
 232
 233 #ifdef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 234 extern krb5_error_code
 235 krb5int_c_mandatory_cksumtype(krb5_context, krb5_enctype, krb5_cksumtype *);
 236 #endif
 237
 238 OM_uint32
 239 rfc3961ChecksumTypeForKey(OM_uint32 *minor,
 240                           krb5_keyblock *key,
 241                           krb5_cksumtype *cksumtype)
 242 {
 243     krb5_context krbContext;
 244 #ifndef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 245     krb5_data data;
 246     krb5_checksum cksum;
 247 #endif
 248
 249     GSSEAP_KRB_INIT(&krbContext);
 250
 251 #ifdef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 252     *minor = krb5int_c_mandatory_cksumtype(krbContext, KRB_KEY_TYPE(key),
 253                                            cksumtype);
 254     if (*minor != 0)
 255         return GSS_S_FAILURE;
 256 #else
 257     data.length = 0;
 258     data.data = NULL;
 259
 260     memset(&cksum, 0, sizeof(cksum));
 261
 262     /*
 263      * This is a complete hack but it's the only way to work with
 264      * MIT Kerberos pre-1.9 without using private API, as it does
 265      * not support passing in zero as the checksum type.
 266      */
 267     *minor = krb5_c_make_checksum(krbContext, 0, key, 0, &data, &cksum);
 268     if (*minor != 0)
 269         return GSS_S_FAILURE;
 270
 271 #ifdef HAVE_HEIMDAL_VERSION
 272     *cksumtype = cksum.cksumtype;
 273 #else
 274     *cksumtype = cksum.checksum_type;
 275 #endif
 276
 277     krb5_free_checksum_contents(krbContext, &cksum);
 278 #endif /* HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE */
 279
 280     if (!krb5_c_is_keyed_cksum(*cksumtype)) {
 281         *minor = (OM_uint32)KRB5KRB_AP_ERR_INAPP_CKSUM;
 282         return GSS_S_FAILURE;
 283     }
 284
 285     return GSS_S_COMPLETE;
 286 }
 287
 288 krb5_error_code
 289 krbCryptoLength(krb5_context krbContext,
 290 #ifdef HAVE_HEIMDAL_VERSION
 291                 krb5_crypto krbCrypto,
 292 #else
 293                 krb5_keyblock *key,
 294 #endif
 295                 int type,
 296                 size_t *length)
 297 {
 298 #ifdef HAVE_HEIMDAL_VERSION
 299     return krb5_crypto_length(krbContext, krbCrypto, type, length);
 300 #else
 301     unsigned int len;
 302     krb5_error_code code;
 303
 304     code = krb5_c_crypto_length(krbContext, KRB_KEY_TYPE(key), type, &len);
 305     if (code == 0)
 306         *length = (size_t)len;
 307
 308     return code;
 309 #endif
 310 }
 311
 312 krb5_error_code
 313 krbPaddingLength(krb5_context krbContext,
 314 #ifdef HAVE_HEIMDAL_VERSION
 315                  krb5_crypto krbCrypto,
 316 #else
 317                  krb5_keyblock *key,
 318 #endif
 319                  size_t dataLength,
 320                  size_t *padLength)
 321 {
 322     krb5_error_code code;
 323 #ifdef HAVE_HEIMDAL_VERSION
 324     size_t headerLength, paddingLength;
 325
 326     code = krbCryptoLength(krbContext, krbCrypto,
 327                            KRB5_CRYPTO_TYPE_HEADER, &headerLength);
 328     if (code != 0)
 329         return code;
 330
 331     dataLength += headerLength;
 332
 333     code = krb5_crypto_length(krbContext, krbCrypto,
 334                               KRB5_CRYPTO_TYPE_PADDING, &paddingLength);
 335     if (code != 0)
 336         return code;
 337
 338     if (paddingLength != 0 && (dataLength % paddingLength) != 0)
 339         *padLength = paddingLength - (dataLength % paddingLength);
 340     else
 341         *padLength = 0;
 342
 343     return 0;
 344 #else
 345     unsigned int pad;
 346
 347     code = krb5_c_padding_length(krbContext, KRB_KEY_TYPE(key), dataLength, &pad);
 348     if (code == 0)
 349         *padLength = (size_t)pad;
 350
 351     return code;
 352 #endif /* HAVE_HEIMDAL_VERSION */
 353 }
 354
 355 krb5_error_code
 356 krbBlockSize(krb5_context krbContext,
 357 #ifdef HAVE_HEIMDAL_VERSION
 358                  krb5_crypto krbCrypto,
 359 #else
 360                  krb5_keyblock *key,
 361 #endif
 362                  size_t *blockSize)
 363 {
 364 #ifdef HAVE_HEIMDAL_VERSION
 365     return krb5_crypto_getblocksize(krbContext, krbCrypto, blockSize);
 366 #else
 367     return krb5_c_block_size(krbContext, KRB_KEY_TYPE(key), blockSize);
 368 #endif
 369 }
 370
 371 krb5_error_code
 372 krbEnctypeToString(
 373 #ifdef HAVE_HEIMDAL_VERSION
 374                    krb5_context krbContext,
 375 #else
 376                    krb5_context krbContext GSSEAP_UNUSED,
 377 #endif
 378                    krb5_enctype enctype,
 379                    const char *prefix,
 380                    gss_buffer_t string)
 381 {
 382     krb5_error_code code;
 383 #ifdef HAVE_HEIMDAL_VERSION
 384     char *enctypeBuf = NULL;
 385 #else
 386     char enctypeBuf[128];
 387 #endif
 388     size_t prefixLength, enctypeLength;
 389
 390 #ifdef HAVE_HEIMDAL_VERSION
 391     code = krb5_enctype_to_string(krbContext, enctype, &enctypeBuf);
 392 #else
 393     code = krb5_enctype_to_name(enctype, 0, enctypeBuf, sizeof(enctypeBuf));
 394 #endif
 395     if (code != 0)
 396         return code;
 397
 398     prefixLength = (prefix != NULL) ? strlen(prefix) : 0;
 399     enctypeLength = strlen(enctypeBuf);
 400
 401     string->value = GSSEAP_MALLOC(prefixLength + enctypeLength + 1);
 402     if (string->value == NULL) {
 403 #ifdef HAVE_HEIMDAL_VERSION
 404         krb5_xfree(enctypeBuf);
 405 #endif
 406         return ENOMEM;
 407     }
 408
 409     if (prefixLength != 0)
 410         memcpy(string->value, prefix, prefixLength);
 411     memcpy((char *)string->value + prefixLength, enctypeBuf, enctypeLength);
 412
 413     string->length = prefixLength + enctypeLength;
 414     ((char *)string->value)[string->length] = '\0';
 415
 416 #ifdef HAVE_HEIMDAL_VERSION
 417     krb5_xfree(enctypeBuf);
 418 #endif
 419
 420     return 0;
 421 }
 422
 423 krb5_error_code
 424 krbMakeAuthDataKdcIssued(krb5_context context,
 425                          const krb5_keyblock *key,
 426                          krb5_const_principal issuer,
 427 #ifdef HAVE_HEIMDAL_VERSION
 428                          const AuthorizationData *authdata,
 429                          AuthorizationData *adKdcIssued
 430 #else
 431                          krb5_authdata *const *authdata,
 432                          krb5_authdata ***adKdcIssued
 433 #endif
 434                          )
 435 {
 436 #ifdef HAVE_HEIMDAL_VERSION
 437     krb5_error_code code;
 438     AD_KDCIssued kdcIssued;
 439     AuthorizationDataElement adDatum;
 440     unsigned char *buf;
 441     size_t buf_size, len;
 442     krb5_crypto crypto = NULL;
 443
 444     memset(&kdcIssued, 0, sizeof(kdcIssued));
 445     memset(adKdcIssued, 0, sizeof(*adKdcIssued));
 446
 447     kdcIssued.i_realm = issuer->realm != NULL ? (Realm *)&issuer->realm : NULL;
 448     kdcIssued.i_sname = (PrincipalName *)&issuer->name;
 449     kdcIssued.elements = *authdata;
 450
 451     ASN1_MALLOC_ENCODE(AuthorizationData, buf, buf_size, authdata, &len, code);
 452     if (code != 0)
 453         goto cleanup;
 454
 455     code = krb5_crypto_init(context, key, 0, &crypto);
 456     if (code != 0)
 457         goto cleanup;
 458
 459     code = krb5_create_checksum(context, crypto, KRB5_KU_AD_KDC_ISSUED,
 460                                 0, buf, buf_size, &kdcIssued.ad_checksum);
 461     if (code != 0)
 462         goto cleanup;
 463
 464     free(buf); /* match ASN1_MALLOC_ENCODE */
 465     buf = NULL;
 466
 467     ASN1_MALLOC_ENCODE(AD_KDCIssued, buf, buf_size, &kdcIssued, &len, code);
 468     if (code != 0)
 469         goto cleanup;
 470
 471     adDatum.ad_type = KRB5_AUTHDATA_KDC_ISSUED;
 472     adDatum.ad_data.length = buf_size;
 473     adDatum.ad_data.data = buf;
 474
 475     code = add_AuthorizationData(adKdcIssued, &adDatum);
 476     if (code != 0)
 477         goto cleanup;
 478
 479 cleanup:
 480     if (buf != NULL)
 481         free(buf); /* match ASN1_MALLOC_ENCODE */
 482     if (crypto != NULL)
 483         krb5_crypto_destroy(context, crypto);
 484     free_Checksum(&kdcIssued.ad_checksum);
 485
 486     return code;
 487 #else
 488     return krb5_make_authdata_kdc_issued(context, key, issuer, authdata,
 489                                          adKdcIssued);
 490 #endif /* HAVE_HEIMDAL_VERSION */
 491 }
 492
 493 krb5_error_code
 494 krbMakeCred(krb5_context krbContext,
 495             krb5_auth_context authContext,
 496             krb5_creds *creds,
 497             krb5_data *data)
 498 {
 499     krb5_error_code code;
 500 #ifdef HAVE_HEIMDAL_VERSION
 501     KRB_CRED krbCred;
 502     KrbCredInfo krbCredInfo;
 503     EncKrbCredPart encKrbCredPart;
 504     krb5_keyblock *key;
 505     krb5_crypto krbCrypto = NULL;
 506     krb5_data encKrbCredPartData;
 507     krb5_replay_data rdata;
 508     size_t len;
 509 #else
 510     krb5_data *d = NULL;
 511 #endif
 512
 513     memset(data, 0, sizeof(*data));
 514 #ifdef HAVE_HEIMDAL_VERSION
 515     memset(&krbCred,        0, sizeof(krbCred));
 516     memset(&krbCredInfo,    0, sizeof(krbCredInfo));
 517     memset(&encKrbCredPart, 0, sizeof(encKrbCredPart));
 518     memset(&rdata,          0, sizeof(rdata));
 519
 520     if (authContext->local_subkey)
 521         key = authContext->local_subkey;
 522     else if (authContext->remote_subkey)
 523         key = authContext->remote_subkey;
 524     else
 525         key = authContext->keyblock;
 526
 527     krbCred.pvno = 5;
 528     krbCred.msg_type = krb_cred;
 529     krbCred.tickets.val = (Ticket *)GSSEAP_CALLOC(1, sizeof(Ticket));
 530     if (krbCred.tickets.val == NULL) {
 531         code = ENOMEM;
 532         goto cleanup;
 533     }
 534     krbCred.tickets.len = 1;
 535
 536     code = decode_Ticket(creds->ticket.data,
 537                          creds->ticket.length,
 538                          krbCred.tickets.val, &len);
 539     if (code != 0)
 540         goto cleanup;
 541
 542     krbCredInfo.key         = creds->session;
 543     krbCredInfo.prealm      = &creds->client->realm;
 544     krbCredInfo.pname       = &creds->client->name;
 545     krbCredInfo.flags       = &creds->flags.b;
 546     krbCredInfo.authtime    = &creds->times.authtime;
 547     krbCredInfo.starttime   = &creds->times.starttime;
 548     krbCredInfo.endtime     = &creds->times.endtime;
 549     krbCredInfo.renew_till  = &creds->times.renew_till;
 550     krbCredInfo.srealm      = &creds->server->realm;
 551     krbCredInfo.sname       = &creds->server->name;
 552     krbCredInfo.caddr       = creds->addresses.len ? &creds->addresses : NULL;
 553
 554     encKrbCredPart.ticket_info.len = 1;
 555     encKrbCredPart.ticket_info.val = &krbCredInfo;
 556     if (authContext->flags & KRB5_AUTH_CONTEXT_DO_SEQUENCE) {
 557         rdata.seq                  = authContext->local_seqnumber;
 558         encKrbCredPart.nonce       = (int32_t *)&rdata.seq;
 559     } else {
 560         encKrbCredPart.nonce       = NULL;
 561     }
 562     if (authContext->flags & KRB5_AUTH_CONTEXT_DO_TIME) {
 563         krb5_us_timeofday(krbContext, &rdata.timestamp, &rdata.usec);
 564         encKrbCredPart.timestamp   = &rdata.timestamp;
 565         encKrbCredPart.usec        = &rdata.usec;
 566     } else {
 567         encKrbCredPart.timestamp   = NULL;
 568         encKrbCredPart.usec        = NULL;
 569     }
 570     encKrbCredPart.s_address       = authContext->local_address;
 571     encKrbCredPart.r_address       = authContext->remote_address;
 572
 573     ASN1_MALLOC_ENCODE(EncKrbCredPart, encKrbCredPartData.data,
 574                        encKrbCredPartData.length, &encKrbCredPart,
 575                        &len, code);
 576     if (code != 0)
 577         goto cleanup;
 578
 579     code = krb5_crypto_init(krbContext, key, 0, &krbCrypto);
 580     if (code != 0)
 581         goto cleanup;
 582
 583     code = krb5_encrypt_EncryptedData(krbContext,
 584                                       krbCrypto,
 585                                       KRB5_KU_KRB_CRED,
 586                                       encKrbCredPartData.data,
 587                                       encKrbCredPartData.length,
 588                                       0,
 589                                       &krbCred.enc_part);
 590     if (code != 0)
 591         goto cleanup;
 592
 593     ASN1_MALLOC_ENCODE(KRB_CRED, data->data, data->length,
 594                        &krbCred, &len, code);
 595     if (code != 0)
 596         goto cleanup;
 597
 598     if (authContext->flags & KRB5_AUTH_CONTEXT_DO_SEQUENCE)
 599         authContext->local_seqnumber++;
 600
 601 cleanup:
 602     if (krbCrypto != NULL)
 603         krb5_crypto_destroy(krbContext, krbCrypto);
 604     free_KRB_CRED(&krbCred);
 605     krb5_data_free(&encKrbCredPartData);
 606
 607     return code;
 608 #else
 609     code = krb5_mk_1cred(krbContext, authContext, creds, &d, NULL);
 610     if (code == 0) {
 611         *data = *d;
 612         GSSEAP_FREE(d);
 613     }
 614
 615     return code;
 616 #endif /* HAVE_HEIMDAL_VERSION */
 617 }