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 for RFC 4121 use by using the following
  77  * derivation function:
  78  *
  79  *    random-to-key(prf(random-to-key([e]msk), "rfc4121-gss-eap"))
  80  *
  81  * where random-to-key and prf are defined in RFC 3961.
  82  */
  83 OM_uint32
  84 gssEapDeriveRfc3961Key(OM_uint32 *minor,
  85                        const unsigned char *key,
  86                        size_t keyLength,
  87                        krb5_enctype enctype,
  88                        krb5_keyblock *pKey)
  89 {
  90     krb5_context context;
  91     krb5_data data, prf;
  92     krb5_keyblock kd;
  93     krb5_error_code code;
  94     size_t keybytes, keylength, prflength;
  95
  96     memset(pKey, 0, sizeof(*pKey));
  97
  98     GSSEAP_KRB_INIT(&context);
  99
 100     KRB_KEY_INIT(&kd);
 101     KRB_KEY_TYPE(&kd) = enctype;
 102
 103     prf.data = NULL;
 104     prf.length = 0;
 105
 106     code = krb5_c_keylengths(context, enctype, &keybytes, &keylength);
 107     if (code != 0)
 108         goto cleanup;
 109
 110     if (keyLength < keybytes) {
 111         code = KRB5_BAD_MSIZE;
 112         goto cleanup;
 113     }
 114
 115     data.length = keybytes;
 116     data.data = (char *)key;
 117
 118     KRB_KEY_DATA(&kd) = GSSEAP_MALLOC(keylength);
 119     if (KRB_KEY_DATA(&kd) == NULL) {
 120         code = ENOMEM;
 121         goto cleanup;
 122     }
 123     KRB_KEY_LENGTH(&kd) = keylength;
 124
 125     /* Convert MSK into a Kerberos key */
 126     code = krb5_c_random_to_key(context, enctype, &data, &kd);
 127     if (code != 0)
 128         goto cleanup;
 129
 130     data.length = sizeof("rfc4121-gss-eap") - 1;
 131     data.data = "rfc4121-gss-eap";
 132
 133     /* Plug derivation constant and key into PRF */
 134     code = krb5_c_prf_length(context, enctype, &prflength);
 135     if (code != 0)
 136         goto cleanup;
 137
 138     if (prflength < keybytes) {
 139         code = KRB5_CRYPTO_INTERNAL;
 140         goto cleanup;
 141     }
 142     prf.length = keybytes;
 143     prf.data = GSSEAP_MALLOC(prflength);
 144     if (data.data == NULL) {
 145         code = ENOMEM;
 146         goto cleanup;
 147     }
 148
 149     code = krb5_c_prf(context, &kd, &data, &prf);
 150     if (code != 0)
 151         goto cleanup;
 152
 153     /* Finally, convert PRF output into a new key which we will return */
 154     code = krb5_c_random_to_key(context, enctype, &prf, &kd);
 155     if (code != 0)
 156         goto cleanup;
 157
 158     *pKey = kd;
 159     KRB_KEY_DATA(&kd) = NULL;
 160
 161 cleanup:
 162     if (KRB_KEY_DATA(&kd) != NULL) {
 163         memset(KRB_KEY_DATA(&kd), 0, KRB_KEY_LENGTH(&kd));
 164         GSSEAP_FREE(KRB_KEY_DATA(&kd));
 165     }
 166     if (prf.data != NULL) {
 167         memset(prf.data, 0, prf.length);
 168         GSSEAP_FREE(prf.data);
 169     }
 170
 171     *minor = code;
 172     return (code == 0) ? GSS_S_COMPLETE : GSS_S_FAILURE;
 173 }
 174
 175 #ifdef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 176 extern krb5_error_code
 177 krb5int_c_mandatory_cksumtype(krb5_context, krb5_enctype, krb5_cksumtype *);
 178 #endif
 179
 180 OM_uint32
 181 rfc3961ChecksumTypeForKey(OM_uint32 *minor,
 182                           krb5_keyblock *key,
 183                           krb5_cksumtype *cksumtype)
 184 {
 185     krb5_context krbContext;
 186 #ifndef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 187     krb5_data data;
 188     krb5_checksum cksum;
 189 #endif
 190
 191     GSSEAP_KRB_INIT(&krbContext);
 192
 193 #ifdef HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE
 194     *minor = krb5int_c_mandatory_cksumtype(krbContext, KRB_KEY_TYPE(key),
 195                                            cksumtype);
 196     if (*minor != 0)
 197         return GSS_S_FAILURE;
 198 #else
 199     data.length = 0;
 200     data.data = NULL;
 201
 202     memset(&cksum, 0, sizeof(cksum));
 203
 204     *minor = krb5_c_make_checksum(krbContext, 0, key, 0, &data, &cksum);
 205     if (*minor != 0)
 206         return GSS_S_FAILURE;
 207
 208     *cksumtype = cksum.checksum_type;
 209
 210     krb5_free_checksum_contents(krbContext, &cksum);
 211 #endif /* HAVE_KRB5INT_C_MANDATORY_CKSUMTYPE */
 212
 213     return GSS_S_COMPLETE;
 214 }