crypto/dist/heimdal/lib/krb5/mit_glue.c

   1 /*
   2  * Copyright (c) 2003 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "krb5_locl.h"
  35 __RCSID("$Heimdal: mit_glue.c 20042 2007-01-23 20:37:43Z lha $"
  36         "$NetBSD$");
  37
  38 /*
  39  * Glue for MIT API
  40  */
  41
  42 krb5_error_code KRB5_LIB_FUNCTION
  43 krb5_c_make_checksum(krb5_context context,
  44                      krb5_cksumtype cksumtype,
  45                      const krb5_keyblock *key,
  46                      krb5_keyusage usage,
  47                      const krb5_data *input,
  48                      krb5_checksum *cksum)
  49 {
  50     krb5_error_code ret;
  51     krb5_crypto crypto;
  52
  53     ret = krb5_crypto_init(context, key, 0, &crypto);
  54     if (ret)
  55         return ret;
  56
  57     ret = krb5_create_checksum(context, crypto,  usage, cksumtype,
  58                                input->data, input->length, cksum);
  59     krb5_crypto_destroy(context, crypto);
  60
  61     return ret ;
  62 }
  63
  64 krb5_error_code KRB5_LIB_FUNCTION
  65 krb5_c_verify_checksum(krb5_context context, const krb5_keyblock *key,
  66                        krb5_keyusage usage, const krb5_data *data,
  67                        const krb5_checksum *cksum, krb5_boolean *valid)
  68 {
  69     krb5_error_code ret;
  70     krb5_checksum data_cksum;
  71
  72     *valid = 0;
  73
  74     ret = krb5_c_make_checksum(context, cksum->cksumtype,
  75                                key, usage, data, &data_cksum);
  76     if (ret)
  77         return ret;
  78
  79     if (data_cksum.cksumtype == cksum->cksumtype
  80         && data_cksum.checksum.length == cksum->checksum.length
  81         && memcmp(data_cksum.checksum.data, cksum->checksum.data, cksum->checksum.length) == 0)
  82         *valid = 1;
  83
  84     krb5_free_checksum_contents(context, &data_cksum);
  85
  86     return 0;
  87 }
  88
  89 krb5_error_code KRB5_LIB_FUNCTION
  90 krb5_c_get_checksum(krb5_context context, const krb5_checksum *cksum,
  91                     krb5_cksumtype *type, krb5_data **data)
  92 {
  93     krb5_error_code ret;
  94
  95     if (type)
  96         *type = cksum->cksumtype;
  97     if (data) {
  98         *data = malloc(sizeof(**data));
  99         if (*data == NULL)
 100             return ENOMEM;
 101
 102         ret = der_copy_octet_string(&cksum->checksum, *data);
 103         if (ret) {
 104             free(*data);
 105             *data = NULL;
 106             return ret;
 107         }
 108     }
 109     return 0;
 110 }
 111
 112 krb5_error_code KRB5_LIB_FUNCTION
 113 krb5_c_set_checksum(krb5_context context, krb5_checksum *cksum,
 114                     krb5_cksumtype type, const krb5_data *data)
 115 {
 116     cksum->cksumtype = type;
 117     return der_copy_octet_string(data, &cksum->checksum);
 118 }
 119
 120 void KRB5_LIB_FUNCTION
 121 krb5_free_checksum (krb5_context context, krb5_checksum *cksum)
 122 {
 123     krb5_checksum_free(context, cksum);
 124     free(cksum);
 125 }
 126
 127 void KRB5_LIB_FUNCTION
 128 krb5_free_checksum_contents(krb5_context context, krb5_checksum *cksum)
 129 {
 130     krb5_checksum_free(context, cksum);
 131     memset(cksum, 0, sizeof(*cksum));
 132 }
 133
 134 void KRB5_LIB_FUNCTION
 135 krb5_checksum_free(krb5_context context, krb5_checksum *cksum)
 136 {
 137     free_Checksum(cksum);
 138 }
 139
 140 krb5_boolean KRB5_LIB_FUNCTION
 141 krb5_c_valid_enctype (krb5_enctype etype)
 142 {
 143     return krb5_enctype_valid(NULL, etype);
 144 }
 145
 146 krb5_boolean KRB5_LIB_FUNCTION
 147 krb5_c_valid_cksumtype(krb5_cksumtype ctype)
 148 {
 149     return krb5_cksumtype_valid(NULL, ctype);
 150 }
 151
 152 krb5_boolean KRB5_LIB_FUNCTION
 153 krb5_c_is_coll_proof_cksum(krb5_cksumtype ctype)
 154 {
 155     return krb5_checksum_is_collision_proof(NULL, ctype);
 156 }
 157
 158 krb5_boolean KRB5_LIB_FUNCTION
 159 krb5_c_is_keyed_cksum(krb5_cksumtype ctype)
 160 {
 161     return krb5_checksum_is_keyed(NULL, ctype);
 162 }
 163
 164 krb5_error_code KRB5_LIB_FUNCTION
 165 krb5_copy_checksum (krb5_context context,
 166                     const krb5_checksum *old,
 167                     krb5_checksum **new)
 168 {
 169     *new = malloc(sizeof(**new));
 170     if (*new == NULL)
 171         return ENOMEM;
 172     return copy_Checksum(old, *new);
 173 }
 174
 175 krb5_error_code KRB5_LIB_FUNCTION
 176 krb5_c_checksum_length (krb5_context context, krb5_cksumtype cksumtype,
 177                         size_t *length)
 178 {
 179     return krb5_checksumsize(context, cksumtype, length);
 180 }
 181
 182 krb5_error_code KRB5_LIB_FUNCTION
 183 krb5_c_block_size(krb5_context context,
 184                   krb5_enctype enctype,
 185                   size_t *blocksize)
 186 {
 187     krb5_error_code ret;
 188     krb5_crypto crypto;
 189     krb5_keyblock key;
 190
 191     ret = krb5_generate_random_keyblock(context, enctype, &key);
 192     if (ret)
 193         return ret;
 194
 195     ret = krb5_crypto_init(context, &key, 0, &crypto);
 196     krb5_free_keyblock_contents(context, &key);
 197     if (ret)
 198         return ret;
 199     ret = krb5_crypto_getblocksize(context, crypto, blocksize);
 200     krb5_crypto_destroy(context, crypto);
 201
 202     return ret;
 203 }
 204
 205 krb5_error_code KRB5_LIB_FUNCTION
 206 krb5_c_decrypt(krb5_context context,
 207                const krb5_keyblock key,
 208                krb5_keyusage usage,
 209                const krb5_data *ivec,
 210                krb5_enc_data *input,
 211                krb5_data *output)
 212 {
 213     krb5_error_code ret;
 214     krb5_crypto crypto;
 215
 216     ret = krb5_crypto_init(context, &key, input->enctype, &crypto);
 217     if (ret)
 218         return ret;
 219
 220     if (ivec) {
 221         size_t blocksize;
 222
 223         ret = krb5_crypto_getblocksize(context, crypto, &blocksize);
 224         if (ret) {
 225         krb5_crypto_destroy(context, crypto);
 226         return ret;
 227         }
 228
 229         if (blocksize > ivec->length) {
 230             krb5_crypto_destroy(context, crypto);
 231             return KRB5_BAD_MSIZE;
 232         }
 233     }
 234
 235     ret = krb5_decrypt_ivec(context, crypto, usage,
 236                             input->ciphertext.data, input->ciphertext.length,
 237                             output,
 238                             ivec ? ivec->data : NULL);
 239
 240     krb5_crypto_destroy(context, crypto);
 241
 242     return ret ;
 243 }
 244
 245 krb5_error_code KRB5_LIB_FUNCTION
 246 krb5_c_encrypt(krb5_context context,
 247                const krb5_keyblock *key,
 248                krb5_keyusage usage,
 249                const krb5_data *ivec,
 250                const krb5_data *input,
 251                krb5_enc_data *output)
 252 {
 253     krb5_error_code ret;
 254     krb5_crypto crypto;
 255
 256     ret = krb5_crypto_init(context, key, 0, &crypto);
 257     if (ret)
 258         return ret;
 259
 260     if (ivec) {
 261         size_t blocksize;
 262
 263         ret = krb5_crypto_getblocksize(context, crypto, &blocksize);
 264         if (ret) {
 265             krb5_crypto_destroy(context, crypto);
 266             return ret;
 267         }
 268
 269         if (blocksize > ivec->length) {
 270             krb5_crypto_destroy(context, crypto);
 271             return KRB5_BAD_MSIZE;
 272         }
 273     }
 274
 275     ret = krb5_encrypt_ivec(context, crypto, usage,
 276                             input->data, input->length,
 277                             &output->ciphertext,
 278                             ivec ? ivec->data : NULL);
 279     output->kvno = 0;
 280     krb5_crypto_getenctype(context, crypto, &output->enctype);
 281
 282     krb5_crypto_destroy(context, crypto);
 283
 284     return ret ;
 285 }
 286
 287 krb5_error_code KRB5_LIB_FUNCTION
 288 krb5_c_encrypt_length(krb5_context context,
 289                       krb5_enctype enctype,
 290                       size_t inputlen,
 291                       size_t *length)
 292 {
 293     krb5_error_code ret;
 294     krb5_crypto crypto;
 295     krb5_keyblock key;
 296
 297     ret = krb5_generate_random_keyblock(context, enctype, &key);
 298     if (ret)
 299         return ret;
 300
 301     ret = krb5_crypto_init(context, &key, 0, &crypto);
 302     krb5_free_keyblock_contents(context, &key);
 303     if (ret)
 304         return ret;
 305
 306     *length = krb5_get_wrapped_length(context, crypto, inputlen);
 307     krb5_crypto_destroy(context, crypto);
 308
 309     return 0;
 310 }
 311
 312 krb5_error_code KRB5_LIB_FUNCTION
 313 krb5_c_enctype_compare(krb5_context context,
 314                        krb5_enctype e1,
 315                        krb5_enctype e2,
 316                        krb5_boolean *similar)
 317 {
 318     *similar = krb5_enctypes_compatible_keys(context, e1, e2);
 319     return 0;
 320 }
 321
 322 krb5_error_code KRB5_LIB_FUNCTION
 323 krb5_c_make_random_key(krb5_context context,
 324                        krb5_enctype enctype,
 325                        krb5_keyblock *random_key)
 326 {
 327     return krb5_generate_random_keyblock(context, enctype, random_key);
 328 }
 329
 330 krb5_error_code KRB5_LIB_FUNCTION
 331 krb5_c_keylengths(krb5_context context,
 332                   krb5_enctype enctype,
 333                   size_t *ilen,
 334                   size_t *keylen)
 335 {
 336     krb5_error_code ret;
 337
 338     ret = krb5_enctype_keybits(context, enctype, ilen);
 339     if (ret)
 340         return ret;
 341     *ilen = (*ilen + 7) / 8;
 342     return krb5_enctype_keysize(context, enctype, keylen);
 343 }
 344
 345 krb5_error_code KRB5_LIB_FUNCTION
 346 krb5_c_prf_length(krb5_context context,
 347                   krb5_enctype type,
 348                   size_t *length)
 349 {
 350     return krb5_crypto_prf_length(context, type, length);
 351 }
 352
 353 krb5_error_code KRB5_LIB_FUNCTION
 354 krb5_c_prf(krb5_context context,
 355            const krb5_keyblock *key,
 356            const krb5_data *input,
 357            krb5_data *output)
 358 {
 359     krb5_crypto crypto;
 360     krb5_error_code ret;
 361
 362     ret = krb5_crypto_init(context, key, 0, &crypto);
 363     if (ret)
 364         return ret;
 365
 366     ret = krb5_crypto_prf(context, crypto, input, output);
 367     krb5_crypto_destroy(context, crypto);
 368
 369     return ret;
 370 }