src/lib/gssapi/krb5/util_cksum.c

   1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
   2 /*
   3  * Copyright 1993 by OpenVision Technologies, Inc.
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software
   6  * and its documentation for any purpose is hereby granted without fee,
   7  * provided that the above copyright notice appears in all copies and
   8  * that both that copyright notice and this permission notice appear in
   9  * supporting documentation, and that the name of OpenVision not be used
  10  * in advertising or publicity pertaining to distribution of the software
  11  * without specific, written prior permission. OpenVision makes no
  12  * representations about the suitability of this software for any
  13  * purpose.  It is provided "as is" without express or implied warranty.
  14  *
  15  * OPENVISION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  17  * EVENT SHALL OPENVISION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  19  * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  20  * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  21  * PERFORMANCE OF THIS SOFTWARE.
  22  */
  23
  24 #include "gssapiP_krb5.h"
  25 #ifdef HAVE_MEMORY_H
  26 #include <memory.h>
  27 #endif
  28
  29 /* Checksumming the channel bindings always uses plain MD5.  */
  30 krb5_error_code
  31 kg_checksum_channel_bindings(context, cb, cksum)
  32     krb5_context context;
  33     gss_channel_bindings_t cb;
  34     krb5_checksum *cksum;
  35 {
  36     size_t len;
  37     char *buf = 0;
  38     char *ptr;
  39     size_t sumlen;
  40     krb5_data plaind;
  41     krb5_error_code code;
  42
  43     /* initialize the the cksum */
  44     code = krb5_c_checksum_length(context, CKSUMTYPE_RSA_MD5, &sumlen);
  45     if (code)
  46         return(code);
  47
  48     cksum->checksum_type = CKSUMTYPE_RSA_MD5;
  49     cksum->length = sumlen;
  50     cksum->magic = KV5M_CHECKSUM;
  51
  52     /* generate a buffer full of zeros if no cb specified */
  53
  54     if (cb == GSS_C_NO_CHANNEL_BINDINGS) {
  55         if ((cksum->contents = (krb5_octet *) xmalloc(cksum->length)) == NULL) {
  56             return(ENOMEM);
  57         }
  58         memset(cksum->contents, '\0', cksum->length);
  59         return(0);
  60     }
  61
  62     /* create the buffer to checksum into */
  63
  64     len = (sizeof(krb5_int32)*5+
  65            cb->initiator_address.length+
  66            cb->acceptor_address.length+
  67            cb->application_data.length);
  68
  69     if ((buf = (char *) xmalloc(len)) == NULL)
  70         return(ENOMEM);
  71
  72     /* helper macros.  This code currently depends on a long being 32
  73        bits, and htonl dtrt. */
  74
  75     ptr = buf;
  76
  77     TWRITE_INT(ptr, cb->initiator_addrtype, 0);
  78     TWRITE_BUF(ptr, cb->initiator_address, 0);
  79     TWRITE_INT(ptr, cb->acceptor_addrtype, 0);
  80     TWRITE_BUF(ptr, cb->acceptor_address, 0);
  81     TWRITE_BUF(ptr, cb->application_data, 0);
  82
  83     /* checksum the data */
  84
  85     plaind.length = len;
  86     plaind.data = buf;
  87
  88     code = krb5_c_make_checksum(context, CKSUMTYPE_RSA_MD5, 0, 0,
  89                                 &plaind, cksum);
  90     if (buf)
  91         xfree(buf);
  92     return code;
  93 }
  94
  95 krb5_error_code
  96 kg_make_checksum_iov_v1(krb5_context context,
  97                         krb5_cksumtype type,
  98                         size_t cksum_len,
  99                         krb5_key seq,
 100                         krb5_key enc,
 101                         krb5_keyusage sign_usage,
 102                         gss_iov_buffer_desc *iov,
 103                         int iov_count,
 104                         int toktype,
 105                         krb5_checksum *checksum)
 106 {
 107     krb5_error_code code;
 108     gss_iov_buffer_desc *header;
 109     krb5_crypto_iov *kiov;
 110     int i = 0, j;
 111     size_t conf_len = 0, token_header_len;
 112
 113     header = kg_locate_header_iov(iov, iov_count, toktype);
 114     assert(header != NULL);
 115
 116     kiov = calloc(iov_count + 3, sizeof(krb5_crypto_iov));
 117     if (kiov == NULL)
 118         return ENOMEM;
 119
 120     /* Checksum over ( Header | Confounder | Data | Pad ) */
 121     if (toktype == KG_TOK_WRAP_MSG)
 122         conf_len = kg_confounder_size(context, enc->keyblock.enctype);
 123
 124     /* Checksum output */
 125     kiov[i].flags = KRB5_CRYPTO_TYPE_CHECKSUM;
 126     kiov[i].data.length = checksum->length;
 127     kiov[i].data.data = xmalloc(checksum->length);
 128     if (kiov[i].data.data == NULL) {
 129         xfree(kiov);
 130         return ENOMEM;
 131     }
 132     i++;
 133
 134     /* Header | SND_SEQ | SGN_CKSUM | Confounder */
 135     token_header_len = 16 + cksum_len + conf_len;
 136
 137     /* Header (calculate from end because of variable length ASN.1 header) */
 138     kiov[i].flags = KRB5_CRYPTO_TYPE_SIGN_ONLY;
 139     kiov[i].data.length = 8;
 140     kiov[i].data.data = (char *)header->buffer.value + header->buffer.length - token_header_len;
 141     i++;
 142
 143     /* Confounder */
 144     if (toktype == KG_TOK_WRAP_MSG) {
 145         kiov[i].flags = KRB5_CRYPTO_TYPE_DATA;
 146         kiov[i].data.length = conf_len;
 147         kiov[i].data.data = (char *)header->buffer.value + header->buffer.length - conf_len;
 148         i++;
 149     }
 150
 151     for (j = 0; j < iov_count; j++) {
 152         kiov[i].flags = kg_translate_flag_iov(iov[j].type);
 153         kiov[i].data.length = iov[j].buffer.length;
 154         kiov[i].data.data = (char *)iov[j].buffer.value;
 155         i++;
 156     }
 157
 158     code = krb5_k_make_checksum_iov(context, type, seq, sign_usage, kiov, i);
 159     if (code == 0) {
 160         checksum->length = kiov[0].data.length;
 161         checksum->contents = (unsigned char *)kiov[0].data.data;
 162     } else
 163         free(kiov[0].data.data);
 164
 165     xfree(kiov);
 166
 167     return code;
 168 }
 169
 170 static krb5_error_code
 171 checksum_iov_v3(krb5_context context,
 172                 krb5_cksumtype type,
 173                 size_t rrc,
 174                 krb5_key key,
 175                 krb5_keyusage sign_usage,
 176                 gss_iov_buffer_desc *iov,
 177                 int iov_count,
 178                 int toktype,
 179                 krb5_boolean verify,
 180                 krb5_boolean *valid)
 181 {
 182     krb5_error_code code;
 183     gss_iov_buffer_desc *header;
 184     gss_iov_buffer_desc *trailer;
 185     krb5_crypto_iov *kiov;
 186     size_t kiov_count;
 187     int i = 0, j;
 188     unsigned int k5_checksumlen;
 189
 190     if (verify)
 191         *valid = FALSE;
 192
 193     code = krb5_c_crypto_length(context, key->keyblock.enctype, KRB5_CRYPTO_TYPE_CHECKSUM, &k5_checksumlen);
 194     if (code != 0)
 195         return code;
 196
 197     header = kg_locate_header_iov(iov, iov_count, toktype);
 198     assert(header != NULL);
 199
 200     trailer = kg_locate_iov(iov, iov_count, GSS_IOV_BUFFER_TYPE_TRAILER);
 201     assert(rrc != 0 || trailer != NULL);
 202
 203     if (trailer == NULL) {
 204         if (rrc != k5_checksumlen)
 205             return KRB5_BAD_MSIZE;
 206         if (header->buffer.length != 16 + k5_checksumlen)
 207             return KRB5_BAD_MSIZE;
 208     } else if (trailer->buffer.length != k5_checksumlen)
 209         return KRB5_BAD_MSIZE;
 210
 211     kiov_count = 2 + iov_count;
 212     kiov = (krb5_crypto_iov *)xmalloc(kiov_count * sizeof(krb5_crypto_iov));
 213     if (kiov == NULL)
 214         return ENOMEM;
 215
 216     /* Checksum over ( Data | Header ) */
 217
 218     /* Data */
 219     for (j = 0; j < iov_count; j++) {
 220         kiov[i].flags = kg_translate_flag_iov(iov[j].type);
 221         kiov[i].data.length = iov[j].buffer.length;
 222         kiov[i].data.data = (char *)iov[j].buffer.value;
 223         i++;
 224     }
 225
 226     /* Header */
 227     kiov[i].flags = KRB5_CRYPTO_TYPE_SIGN_ONLY;
 228     kiov[i].data.length = 16;
 229     kiov[i].data.data = (char *)header->buffer.value;
 230     i++;
 231
 232     /* Checksum */
 233     kiov[i].flags = KRB5_CRYPTO_TYPE_CHECKSUM;
 234     if (trailer == NULL) {
 235         kiov[i].data.length = header->buffer.length - 16;
 236         kiov[i].data.data = (char *)header->buffer.value + 16;
 237     } else {
 238         kiov[i].data.length = trailer->buffer.length;
 239         kiov[i].data.data = (char *)trailer->buffer.value;
 240     }
 241     i++;
 242
 243     if (verify)
 244         code = krb5_k_verify_checksum_iov(context, type, key, sign_usage, kiov, kiov_count, valid);
 245     else
 246         code = krb5_k_make_checksum_iov(context, type, key, sign_usage, kiov, kiov_count);
 247
 248     xfree(kiov);
 249
 250     return code;
 251 }
 252
 253 krb5_error_code
 254 kg_make_checksum_iov_v3(krb5_context context,
 255                         krb5_cksumtype type,
 256                         size_t rrc,
 257                         krb5_key key,
 258                         krb5_keyusage sign_usage,
 259                         gss_iov_buffer_desc *iov,
 260                         int iov_count,
 261                         int toktype)
 262 {
 263     return checksum_iov_v3(context, type, rrc, key,
 264                            sign_usage, iov, iov_count, toktype, 0, NULL);
 265 }
 266
 267 krb5_error_code
 268 kg_verify_checksum_iov_v3(krb5_context context,
 269                           krb5_cksumtype type,
 270                           size_t rrc,
 271                           krb5_key key,
 272                           krb5_keyusage sign_usage,
 273                           gss_iov_buffer_desc *iov,
 274                           int iov_count,
 275                           int toktype,
 276                           krb5_boolean *valid)
 277 {
 278     return checksum_iov_v3(context, type, rrc, key,
 279                            sign_usage, iov, iov_count, toktype, 1, valid);
 280 }