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

   1 /*
   2  * Copyright (c) 2010, 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 static GSSEAP_THREAD_ONCE krbContextKeyOnce = GSSEAP_ONCE_INITIALIZER;
  40 static GSSEAP_THREAD_KEY krbContextKey;
  41
  42 static void
  43 destroyKrbContext(void *arg)
  44 {
  45     krb5_context context = (krb5_context)arg;
  46
  47     if (context != NULL)
  48         krb5_free_context(context);
  49 }
  50
  51 static void
  52 createKrbContextKey(void)
  53 {
  54     GSSEAP_KEY_CREATE(&krbContextKey, destroyKrbContext);
  55 }
  56
  57 OM_uint32
  58 gssEapKerberosInit(OM_uint32 *minor, krb5_context *context)
  59 {
  60     *minor = 0;
  61
  62     GSSEAP_ONCE(&krbContextKeyOnce, createKrbContextKey);
  63
  64     *context = GSSEAP_GETSPECIFIC(krbContextKey);
  65     if (*context == NULL) {
  66         *minor = krb5_init_context(context);
  67         if (*minor == 0) {
  68             if (GSSEAP_SETSPECIFIC(krbContextKey, *context) != 0) {
  69                 *minor = errno;
  70                 krb5_free_context(*context);
  71                 *context = NULL;
  72             }
  73         }
  74     }
  75
  76     return *minor == 0 ? GSS_S_COMPLETE : GSS_S_FAILURE;
  77 }
  78
  79 /*
  80  * Derive a key K for RFC 4121 use by using the following
  81  * derivation function (based on RFC 4402);
  82  *
  83  * KMSK = random-to-key(MSK)
  84  * Tn = pseudo-random(KMSK, n || "rfc4121-gss-eap")
  85  * L = output key size
  86  * K = truncate(L, T1 || T2 || .. || Tn)
  87  */
  88 OM_uint32
  89 gssEapDeriveRfc3961Key(OM_uint32 *minor,
  90                        const unsigned char *inputKey,
  91                        size_t inputKeyLength,
  92                        krb5_enctype encryptionType,
  93                        krb5_keyblock *pKey)
  94 {
  95     krb5_context krbContext;
  96     krb5_data data, ns, t, prfOut;
  97     krb5_keyblock kd;
  98     krb5_error_code code;
  99     size_t randomLength, keyLength, prfLength;
 100     unsigned char constant[4 + sizeof("rfc4121-gss-eap") - 1], *p;
 101     ssize_t i, remain;
 102
 103     assert(encryptionType != ENCTYPE_NULL);
 104
 105     memset(pKey, 0, sizeof(*pKey));
 106
 107     GSSEAP_KRB_INIT(&krbContext);
 108
 109     KRB_KEY_INIT(&kd);
 110     KRB_KEY_TYPE(&kd) = encryptionType;
 111
 112     t.data = NULL;
 113     t.length = 0;
 114
 115     prfOut.data = NULL;
 116     prfOut.length = 0;
 117
 118     code = krb5_c_keylengths(krbContext, encryptionType,
 119                              &randomLength, &keyLength);
 120     if (code != 0)
 121         goto cleanup;
 122
 123     data.length = MIN(inputKeyLength, randomLength);
 124     data.data = (char *)inputKey;
 125
 126     KRB_KEY_DATA(&kd) = GSSEAP_MALLOC(keyLength);
 127     if (KRB_KEY_DATA(&kd) == NULL) {
 128         code = ENOMEM;
 129         goto cleanup;
 130     }
 131     KRB_KEY_LENGTH(&kd) = keyLength;
 132
 133     /* Convert MSK into a Kerberos key */
 134     code = krb5_c_random_to_key(krbContext, encryptionType, &data, &kd);
 135     if (code != 0)
 136         goto cleanup;
 137
 138     memset(&constant[0], 0, 4);
 139     memcpy(&constant[4], "rfc4121-gss-eap", sizeof("rfc4121-gss-eap") - 1);
 140
 141     ns.length = sizeof(constant);
 142     ns.data = (char *)constant;
 143
 144     /* Plug derivation constant and key into PRF */
 145     code = krb5_c_prf_length(krbContext, encryptionType, &prfLength);
 146     if (code != 0)
 147         goto cleanup;
 148
 149     t.length = prfLength;
 150     t.data = GSSEAP_MALLOC(t.length);
 151     if (t.data == NULL) {
 152         code = ENOMEM;
 153         goto cleanup;
 154     }
 155
 156     prfOut.length = randomLength;
 157     prfOut.data = GSSEAP_MALLOC(prfOut.length);
 158     if (prfOut.data == NULL) {
 159         code = ENOMEM;
 160         goto cleanup;
 161     }
 162
 163     for (i = 0, p = (unsigned char *)prfOut.data, remain = randomLength;
 164          remain > 0;
 165          p += t.length, remain -= t.length, i++)
 166     {
 167         store_uint32_be(i, ns.data);
 168
 169         code = krb5_c_prf(krbContext, &kd, &ns, &t);
 170         if (code != 0)
 171             goto cleanup;
 172
 173         memcpy(p, t.data, MIN(t.length, remain));
 174      }
 175
 176     /* Finally, convert PRF output into a new key which we will return */
 177     code = krb5_c_random_to_key(krbContext, encryptionType, &prfOut, &kd);
 178     if (code != 0)
 179         goto cleanup;
 180
 181     *pKey = kd;
 182     KRB_KEY_DATA(&kd) = NULL;
 183
 184 cleanup:
 185     if (KRB_KEY_DATA(&kd) != NULL) {
 186         memset(KRB_KEY_DATA(&kd), 0, KRB_KEY_LENGTH(&kd));
 187         GSSEAP_FREE(KRB_KEY_DATA(&kd));
 188     }
 189     if (t.data != NULL) {
 190         memset(t.data, 0, t.length);
 191         GSSEAP_FREE(t.data);
 192     }
 193     if (prfOut.data != NULL) {
 194         memset(prfOut.data, 0, prfOut.length);
 195         GSSEAP_FREE(prfOut.data);
 196     }
 197     *minor = code;
 198     return (code == 0) ? GSS_S_COMPLETE : GSS_S_FAILURE;
 199 }
 200
 201 #ifdef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 202 extern krb5_error_code
 203 krb5int_c_mandatory_cksumtype(krb5_context, krb5_enctype, krb5_cksumtype *);
 204 #endif
 205
 206 OM_uint32
 207 rfc3961ChecksumTypeForKey(OM_uint32 *minor,
 208                           krb5_keyblock *key,
 209                           krb5_cksumtype *cksumtype)
 210 {
 211     krb5_context krbContext;
 212 #ifndef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 213     krb5_data data;
 214     krb5_checksum cksum;
 215 #endif
 216
 217     GSSEAP_KRB_INIT(&krbContext);
 218
 219 #ifdef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 220     *minor = krb5int_c_mandatory_cksumtype(krbContext, KRB_KEY_TYPE(key),
 221                                            cksumtype);
 222     if (*minor != 0)
 223         return GSS_S_FAILURE;
 224 #else
 225     data.length = 0;
 226     data.data = NULL;
 227
 228     memset(&cksum, 0, sizeof(cksum));
 229
 230     /*
 231      * This is a complete hack but it's the only way to work with
 232      * MIT Kerberos pre-1.9 without using private API, as it does
 233      * not support passing in zero as the checksum type.
 234      */
 235     *minor = krb5_c_make_checksum(krbContext, 0, key, 0, &data, &cksum);
 236     if (*minor != 0)
 237         return GSS_S_FAILURE;
 238
 239     *cksumtype = cksum.checksum_type;
 240
 241     krb5_free_checksum_contents(krbContext, &cksum);
 242 #endif /* HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE */
 243
 244     if (!krb5_c_is_keyed_cksum(*cksumtype)) {
 245         *minor = KRB5KRB_AP_ERR_INAPP_CKSUM;
 246         return GSS_S_FAILURE;
 247     }
 248
 249     return GSS_S_COMPLETE;
 250 }