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