mech_eap/util_crypt.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  * Copyright 2001, 2008 by the Massachusetts Institute of Technology.
  34  * Copyright 1993 by OpenVision Technologies, Inc.
  35  *
  36  * Permission to use, copy, modify, distribute, and sell this software
  37  * and its documentation for any purpose is hereby granted without fee,
  38  * provided that the above copyright notice appears in all copies and
  39  * that both that copyright notice and this permission notice appear in
  40  * supporting documentation, and that the name of OpenVision not be used
  41  * in advertising or publicity pertaining to distribution of the software
  42  * without specific, written prior permission. OpenVision makes no
  43  * representations about the suitability of this software for any
  44  * purpose.  It is provided "as is" without express or implied warranty.
  45  *
  46  * OPENVISION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  47  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  48  * EVENT SHALL OPENVISION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  49  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  50  * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  51  * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  52  * PERFORMANCE OF THIS SOFTWARE.
  53  */
  54 /*
  55  * Copyright (C) 1998 by the FundsXpress, INC.
  56  *
  57  * All rights reserved.
  58  *
  59  * Export of this software from the United States of America may require
  60  * a specific license from the United States Government.  It is the
  61  * responsibility of any person or organization contemplating export to
  62  * obtain such a license before exporting.
  63  *
  64  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  65  * distribute this software and its documentation for any purpose and
  66  * without fee is hereby granted, provided that the above copyright
  67  * notice appear in all copies and that both that copyright notice and
  68  * this permission notice appear in supporting documentation, and that
  69  * the name of FundsXpress. not be used in advertising or publicity pertaining
  70  * to distribution of the software without specific, written prior
  71  * permission.  FundsXpress makes no representations about the suitability of
  72  * this software for any purpose.  It is provided "as is" without express
  73  * or implied warranty.
  74  *
  75  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  76  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  77  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  78  */
  79
  80 /*
  81  * Message protection services: cryptography helpers.
  82  */
  83
  84 #include "gssapiP_eap.h"
  85
  86 /*
  87  * DCE_STYLE indicates actual RRC is EC + RRC
  88  * EC is extra rotate count for DCE_STYLE, pad length otherwise
  89  * RRC is rotate count.
  90  */
  91 static krb5_error_code
  92 mapIov(krb5_context context, int dce_style, size_t ec, size_t rrc,
  93 #ifdef HAVE_HEIMDAL_VERSION
  94        krb5_crypto crypto,
  95 #else
  96        krb5_keyblock *crypto,
  97 #endif
  98        gss_iov_buffer_desc *iov,
  99        int iov_count, krb5_crypto_iov **pkiov,
 100        size_t *pkiov_count)
 101 {
 102     gss_iov_buffer_t header;
 103     gss_iov_buffer_t trailer;
 104     int i = 0, j;
 105     size_t kiov_count;
 106     krb5_crypto_iov *kiov;
 107     size_t k5_headerlen = 0, k5_trailerlen = 0;
 108     size_t gss_headerlen, gss_trailerlen;
 109     krb5_error_code code;
 110
 111     *pkiov = NULL;
 112     *pkiov_count = 0;
 113
 114     header = gssEapLocateIov(iov, iov_count, GSS_IOV_BUFFER_TYPE_HEADER);
 115     GSSEAP_ASSERT(header != NULL);
 116
 117     trailer = gssEapLocateIov(iov, iov_count, GSS_IOV_BUFFER_TYPE_TRAILER);
 118     GSSEAP_ASSERT(trailer == NULL || rrc == 0);
 119
 120     code = krbCryptoLength(context, crypto, KRB5_CRYPTO_TYPE_HEADER, &k5_headerlen);
 121     if (code != 0)
 122         return code;
 123
 124     code = krbCryptoLength(context, crypto, KRB5_CRYPTO_TYPE_TRAILER, &k5_trailerlen);
 125     if (code != 0)
 126         return code;
 127
 128     /* Check header and trailer sizes */
 129     gss_headerlen = 16 /* GSS-Header */ + k5_headerlen; /* Kerb-Header */
 130     gss_trailerlen = ec + 16 /* E(GSS-Header) */ + k5_trailerlen; /* Kerb-Trailer */
 131
 132     /* If we're caller without a trailer, we must rotate by trailer length */
 133     if (trailer == NULL) {
 134         size_t actual_rrc = rrc;
 135
 136         if (dce_style)
 137             actual_rrc += ec; /* compensate for Windows bug */
 138
 139         if (actual_rrc != gss_trailerlen)
 140             return KRB5_BAD_MSIZE;
 141
 142         gss_headerlen += gss_trailerlen;
 143     } else {
 144         if (trailer->buffer.length != gss_trailerlen)
 145             return KRB5_BAD_MSIZE;
 146     }
 147
 148     if (header->buffer.length != gss_headerlen)
 149         return KRB5_BAD_MSIZE;
 150
 151     kiov_count = 3 + iov_count;
 152     kiov = (krb5_crypto_iov *)GSSEAP_MALLOC(kiov_count * sizeof(krb5_crypto_iov));
 153     if (kiov == NULL)
 154         return ENOMEM;
 155
 156     /*
 157      * The krb5 header is located at the end of the GSS header.
 158      */
 159     kiov[i].flags = KRB5_CRYPTO_TYPE_HEADER;
 160     kiov[i].data.length = k5_headerlen;
 161     kiov[i].data.data = (char *)header->buffer.value + header->buffer.length - k5_headerlen;
 162     i++;
 163
 164     for (j = 0; j < iov_count; j++) {
 165         kiov[i].flags = gssEapMapCryptoFlag(iov[j].type);
 166         if (kiov[i].flags == KRB5_CRYPTO_TYPE_EMPTY)
 167             continue;
 168
 169         kiov[i].data.length = iov[j].buffer.length;
 170         kiov[i].data.data = (char *)iov[j].buffer.value;
 171         i++;
 172     }
 173
 174     /*
 175      * The EC and encrypted GSS header are placed in the trailer, which may
 176      * be rotated directly after the plaintext header if no trailer buffer
 177      * is provided.
 178      */
 179     kiov[i].flags = KRB5_CRYPTO_TYPE_DATA;
 180     kiov[i].data.length = ec + 16; /* E(Header) */
 181     if (trailer == NULL)
 182         kiov[i].data.data = (char *)header->buffer.value + 16;
 183     else
 184         kiov[i].data.data = (char *)trailer->buffer.value;
 185     i++;
 186
 187     /*
 188      * The krb5 trailer is placed after the encrypted copy of the
 189      * krb5 header (which may be in the GSS header or trailer).
 190      */
 191     kiov[i].flags = KRB5_CRYPTO_TYPE_TRAILER;
 192     kiov[i].data.length = k5_trailerlen;
 193     kiov[i].data.data = (char *)kiov[i - 1].data.data + ec + 16; /* E(Header) */
 194     i++;
 195
 196     *pkiov = kiov;
 197     *pkiov_count = i;
 198
 199     return 0;
 200 }
 201
 202 int
 203 gssEapEncrypt(krb5_context context,
 204               int dce_style,
 205               size_t ec,
 206               size_t rrc,
 207 #ifdef HAVE_HEIMDAL_VERSION
 208               krb5_crypto crypto,
 209 #else
 210               krb5_keyblock *crypto,
 211 #endif
 212               int usage,
 213               gss_iov_buffer_desc *iov,
 214               int iov_count)
 215 {
 216     krb5_error_code code;
 217     size_t kiov_count;
 218     krb5_crypto_iov *kiov = NULL;
 219
 220     code = mapIov(context, dce_style, ec, rrc, crypto,
 221                   iov, iov_count, &kiov, &kiov_count);
 222     if (code != 0)
 223         goto cleanup;
 224
 225 #ifdef HAVE_HEIMDAL_VERSION
 226     code = krb5_encrypt_iov_ivec(context, crypto, usage, kiov, kiov_count, NULL);
 227 #else
 228     code = krb5_c_encrypt_iov(context, crypto, usage, NULL, kiov, kiov_count);
 229 #endif
 230     if (code != 0)
 231         goto cleanup;
 232
 233 cleanup:
 234     if (kiov != NULL)
 235         GSSEAP_FREE(kiov);
 236
 237     return code;
 238 }
 239
 240 int
 241 gssEapDecrypt(krb5_context context,
 242               int dce_style,
 243               size_t ec,
 244               size_t rrc,
 245 #ifdef HAVE_HEIMDAL_VERSION
 246               krb5_crypto crypto,
 247 #else
 248               krb5_keyblock *crypto,
 249 #endif
 250               int usage,
 251               gss_iov_buffer_desc *iov,
 252               int iov_count)
 253 {
 254     krb5_error_code code;
 255     size_t kiov_count;
 256     krb5_crypto_iov *kiov;
 257
 258     code = mapIov(context, dce_style, ec, rrc, crypto,
 259                   iov, iov_count, &kiov, &kiov_count);
 260     if (code != 0)
 261         goto cleanup;
 262
 263 #ifdef HAVE_HEIMDAL_VERSION
 264     code = krb5_decrypt_iov_ivec(context, crypto, usage, kiov, kiov_count, NULL);
 265 #else
 266     code = krb5_c_decrypt_iov(context, crypto, usage, NULL, kiov, kiov_count);
 267 #endif
 268
 269 cleanup:
 270     if (kiov != NULL)
 271         GSSEAP_FREE(kiov);
 272
 273     return code;
 274 }
 275
 276 int
 277 gssEapMapCryptoFlag(OM_uint32 type)
 278 {
 279     int ktype;
 280
 281     switch (GSS_IOV_BUFFER_TYPE(type)) {
 282     case GSS_IOV_BUFFER_TYPE_DATA:
 283     case GSS_IOV_BUFFER_TYPE_PADDING:
 284         ktype = KRB5_CRYPTO_TYPE_DATA;
 285         break;
 286     case GSS_IOV_BUFFER_TYPE_SIGN_ONLY:
 287         ktype = KRB5_CRYPTO_TYPE_SIGN_ONLY;
 288         break;
 289     default:
 290         ktype = KRB5_CRYPTO_TYPE_EMPTY;
 291         break;
 292     }
 293
 294     return ktype;
 295 }
 296
 297 gss_iov_buffer_t
 298 gssEapLocateIov(gss_iov_buffer_desc *iov, int iov_count, OM_uint32 type)
 299 {
 300     int i;
 301     gss_iov_buffer_t p = GSS_C_NO_IOV_BUFFER;
 302
 303     if (iov == GSS_C_NO_IOV_BUFFER)
 304         return GSS_C_NO_IOV_BUFFER;
 305
 306     for (i = iov_count - 1; i >= 0; i--) {
 307         if (GSS_IOV_BUFFER_TYPE(iov[i].type) == type) {
 308             if (p == GSS_C_NO_IOV_BUFFER)
 309                 p = &iov[i];
 310             else
 311                 return GSS_C_NO_IOV_BUFFER;
 312         }
 313     }
 314
 315     return p;
 316 }
 317
 318 gss_iov_buffer_t
 319 gssEapLocateHeaderIov(gss_iov_buffer_desc *iov, int iov_count, enum gss_eap_token_type toktype)
 320 {
 321     if (toktype == TOK_TYPE_MIC)
 322         return gssEapLocateIov(iov, iov_count, GSS_IOV_BUFFER_TYPE_MIC_TOKEN);
 323     else
 324         return gssEapLocateIov(iov, iov_count, GSS_IOV_BUFFER_TYPE_HEADER);
 325 }
 326
 327 void
 328 gssEapIovMessageLength(gss_iov_buffer_desc *iov,
 329                        int iov_count,
 330                        size_t *data_length_p,
 331                        size_t *assoc_data_length_p)
 332 {
 333     int i;
 334     size_t data_length = 0, assoc_data_length = 0;
 335
 336     GSSEAP_ASSERT(iov != GSS_C_NO_IOV_BUFFER);
 337
 338     *data_length_p = *assoc_data_length_p = 0;
 339
 340     for (i = 0; i < iov_count; i++) {
 341         OM_uint32 type = GSS_IOV_BUFFER_TYPE(iov[i].type);
 342
 343         if (type == GSS_IOV_BUFFER_TYPE_SIGN_ONLY)
 344             assoc_data_length += iov[i].buffer.length;
 345
 346         if (type == GSS_IOV_BUFFER_TYPE_DATA ||
 347             type == GSS_IOV_BUFFER_TYPE_SIGN_ONLY)
 348             data_length += iov[i].buffer.length;
 349     }
 350
 351     *data_length_p = data_length;
 352     *assoc_data_length_p = assoc_data_length;
 353 }
 354
 355 void
 356 gssEapReleaseIov(gss_iov_buffer_desc *iov, int iov_count)
 357 {
 358     int i;
 359     OM_uint32 min_stat;
 360
 361     GSSEAP_ASSERT(iov != GSS_C_NO_IOV_BUFFER);
 362
 363     for (i = 0; i < iov_count; i++) {
 364         if (iov[i].type & GSS_IOV_BUFFER_FLAG_ALLOCATED) {
 365             gss_release_buffer(&min_stat, &iov[i].buffer);
 366             iov[i].type &= ~(GSS_IOV_BUFFER_FLAG_ALLOCATED);
 367         }
 368     }
 369 }
 370
 371 int
 372 gssEapIsIntegrityOnly(gss_iov_buffer_desc *iov, int iov_count)
 373 {
 374     int i;
 375     krb5_boolean has_conf_data = FALSE;
 376
 377     GSSEAP_ASSERT(iov != GSS_C_NO_IOV_BUFFER);
 378
 379     for (i = 0; i < iov_count; i++) {
 380         if (GSS_IOV_BUFFER_TYPE(iov[i].type) == GSS_IOV_BUFFER_TYPE_DATA) {
 381             has_conf_data = TRUE;
 382             break;
 383         }
 384     }
 385
 386     return (has_conf_data == FALSE);
 387 }
 388
 389 int
 390 gssEapAllocIov(gss_iov_buffer_t iov, size_t size)
 391 {
 392     GSSEAP_ASSERT(iov != GSS_C_NO_IOV_BUFFER);
 393     GSSEAP_ASSERT(iov->type & GSS_IOV_BUFFER_FLAG_ALLOCATE);
 394
 395     iov->buffer.length = size;
 396     iov->buffer.value = GSSEAP_MALLOC(size);
 397     if (iov->buffer.value == NULL) {
 398         iov->buffer.length = 0;
 399         return ENOMEM;
 400     }
 401
 402     iov->type |= GSS_IOV_BUFFER_FLAG_ALLOCATED;
 403
 404     return 0;
 405 }