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 #define KRB5_DEPRECATED
  35
  36 #include "krb5_locl.h"
  37
  38 #ifndef HEIMDAL_SMALLER
  39
  40 /*
  41  * Glue for MIT API
  42  */
  43
  44 krb5_error_code KRB5_LIB_FUNCTION
  45 krb5_c_make_checksum(krb5_context context,
  46                      krb5_cksumtype cksumtype,
  47                      const krb5_keyblock *key,
  48                      krb5_keyusage usage,
  49                      const krb5_data *input,
  50                      krb5_checksum *cksum)
  51 {
  52     krb5_error_code ret;
  53     krb5_crypto crypto;
  54
  55     ret = krb5_crypto_init(context, key, 0, &crypto);
  56     if (ret)
  57         return ret;
  58
  59     ret = krb5_create_checksum(context, crypto,  usage, cksumtype,
  60                                input->data, input->length, cksum);
  61     krb5_crypto_destroy(context, crypto);
  62
  63     return ret ;
  64 }
  65
  66 krb5_error_code KRB5_LIB_FUNCTION
  67 krb5_c_verify_checksum(krb5_context context, const krb5_keyblock *key,
  68                        krb5_keyusage usage, const krb5_data *data,
  69                        const krb5_checksum *cksum, krb5_boolean *valid)
  70 {
  71     krb5_error_code ret;
  72     krb5_checksum data_cksum;
  73
  74     *valid = 0;
  75
  76     ret = krb5_c_make_checksum(context, cksum->cksumtype,
  77                                key, usage, data, &data_cksum);
  78     if (ret)
  79         return ret;
  80
  81     if (data_cksum.cksumtype == cksum->cksumtype
  82         && data_cksum.checksum.length == cksum->checksum.length
  83         && memcmp(data_cksum.checksum.data, cksum->checksum.data, cksum->checksum.length) == 0)
  84         *valid = 1;
  85
  86     krb5_free_checksum_contents(context, &data_cksum);
  87
  88     return 0;
  89 }
  90
  91 krb5_error_code KRB5_LIB_FUNCTION
  92 krb5_c_get_checksum(krb5_context context, const krb5_checksum *cksum,
  93                     krb5_cksumtype *type, krb5_data **data)
  94 {
  95     krb5_error_code ret;
  96
  97     if (type)
  98         *type = cksum->cksumtype;
  99     if (data) {
 100         *data = malloc(sizeof(**data));
 101         if (*data == NULL)
 102             return ENOMEM;
 103
 104         ret = der_copy_octet_string(&cksum->checksum, *data);
 105         if (ret) {
 106             free(*data);
 107             *data = NULL;
 108             return ret;
 109         }
 110     }
 111     return 0;
 112 }
 113
 114 krb5_error_code KRB5_LIB_FUNCTION
 115 krb5_c_set_checksum(krb5_context context, krb5_checksum *cksum,
 116                     krb5_cksumtype type, const krb5_data *data)
 117 {
 118     cksum->cksumtype = type;
 119     return der_copy_octet_string(data, &cksum->checksum);
 120 }
 121
 122 void KRB5_LIB_FUNCTION
 123 krb5_free_checksum (krb5_context context, krb5_checksum *cksum)
 124 {
 125     krb5_checksum_free(context, cksum);
 126     free(cksum);
 127 }
 128
 129 void KRB5_LIB_FUNCTION
 130 krb5_free_checksum_contents(krb5_context context, krb5_checksum *cksum)
 131 {
 132     krb5_checksum_free(context, cksum);
 133     memset(cksum, 0, sizeof(*cksum));
 134 }
 135
 136 void KRB5_LIB_FUNCTION
 137 krb5_checksum_free(krb5_context context, krb5_checksum *cksum)
 138 {
 139     free_Checksum(cksum);
 140 }
 141
 142 krb5_boolean KRB5_LIB_FUNCTION
 143 krb5_c_valid_enctype (krb5_enctype etype)
 144 {
 145     return krb5_enctype_valid(NULL, etype);
 146 }
 147
 148 krb5_boolean KRB5_LIB_FUNCTION
 149 krb5_c_valid_cksumtype(krb5_cksumtype ctype)
 150 {
 151     return krb5_cksumtype_valid(NULL, ctype);
 152 }
 153
 154 krb5_boolean KRB5_LIB_FUNCTION
 155 krb5_c_is_coll_proof_cksum(krb5_cksumtype ctype)
 156 {
 157     return krb5_checksum_is_collision_proof(NULL, ctype);
 158 }
 159
 160 krb5_boolean KRB5_LIB_FUNCTION
 161 krb5_c_is_keyed_cksum(krb5_cksumtype ctype)
 162 {
 163     return krb5_checksum_is_keyed(NULL, ctype);
 164 }
 165
 166 krb5_error_code KRB5_LIB_FUNCTION
 167 krb5_copy_checksum (krb5_context context,
 168                     const krb5_checksum *old,
 169                     krb5_checksum **new)
 170 {
 171     *new = malloc(sizeof(**new));
 172     if (*new == NULL)
 173         return ENOMEM;
 174     return copy_Checksum(old, *new);
 175 }
 176
 177 krb5_error_code KRB5_LIB_FUNCTION
 178 krb5_c_checksum_length (krb5_context context, krb5_cksumtype cksumtype,
 179                         size_t *length)
 180 {
 181     return krb5_checksumsize(context, cksumtype, length);
 182 }
 183
 184 krb5_error_code KRB5_LIB_FUNCTION
 185 krb5_c_block_size(krb5_context context,
 186                   krb5_enctype enctype,
 187                   size_t *blocksize)
 188 {
 189     krb5_error_code ret;
 190     krb5_crypto crypto;
 191     krb5_keyblock key;
 192
 193     ret = krb5_generate_random_keyblock(context, enctype, &key);
 194     if (ret)
 195         return ret;
 196
 197     ret = krb5_crypto_init(context, &key, 0, &crypto);
 198     krb5_free_keyblock_contents(context, &key);
 199     if (ret)
 200         return ret;
 201     ret = krb5_crypto_getblocksize(context, crypto, blocksize);
 202     krb5_crypto_destroy(context, crypto);
 203
 204     return ret;
 205 }
 206
 207 krb5_error_code KRB5_LIB_FUNCTION
 208 krb5_c_decrypt(krb5_context context,
 209                const krb5_keyblock key,
 210                krb5_keyusage usage,
 211                const krb5_data *ivec,
 212                krb5_enc_data *input,
 213                krb5_data *output)
 214 {
 215     krb5_error_code ret;
 216     krb5_crypto crypto;
 217
 218     ret = krb5_crypto_init(context, &key, input->enctype, &crypto);
 219     if (ret)
 220         return ret;
 221
 222     if (ivec) {
 223         size_t blocksize;
 224
 225         ret = krb5_crypto_getblocksize(context, crypto, &blocksize);
 226         if (ret) {
 227         krb5_crypto_destroy(context, crypto);
 228         return ret;
 229         }
 230
 231         if (blocksize > ivec->length) {
 232             krb5_crypto_destroy(context, crypto);
 233             return KRB5_BAD_MSIZE;
 234         }
 235     }
 236
 237     ret = krb5_decrypt_ivec(context, crypto, usage,
 238                             input->ciphertext.data, input->ciphertext.length,
 239                             output,
 240                             ivec ? ivec->data : NULL);
 241
 242     krb5_crypto_destroy(context, crypto);
 243
 244     return ret ;
 245 }
 246
 247 krb5_error_code KRB5_LIB_FUNCTION
 248 krb5_c_encrypt(krb5_context context,
 249                const krb5_keyblock *key,
 250                krb5_keyusage usage,
 251                const krb5_data *ivec,
 252                const krb5_data *input,
 253                krb5_enc_data *output)
 254 {
 255     krb5_error_code ret;
 256     krb5_crypto crypto;
 257
 258     ret = krb5_crypto_init(context, key, 0, &crypto);
 259     if (ret)
 260         return ret;
 261
 262     if (ivec) {
 263         size_t blocksize;
 264
 265         ret = krb5_crypto_getblocksize(context, crypto, &blocksize);
 266         if (ret) {
 267             krb5_crypto_destroy(context, crypto);
 268             return ret;
 269         }
 270
 271         if (blocksize > ivec->length) {
 272             krb5_crypto_destroy(context, crypto);
 273             return KRB5_BAD_MSIZE;
 274         }
 275     }
 276
 277     ret = krb5_encrypt_ivec(context, crypto, usage,
 278                             input->data, input->length,
 279                             &output->ciphertext,
 280                             ivec ? ivec->data : NULL);
 281     output->kvno = 0;
 282     krb5_crypto_getenctype(context, crypto, &output->enctype);
 283
 284     krb5_crypto_destroy(context, crypto);
 285
 286     return ret ;
 287 }
 288
 289 krb5_error_code KRB5_LIB_FUNCTION
 290 krb5_c_encrypt_length(krb5_context context,
 291                       krb5_enctype enctype,
 292                       size_t inputlen,
 293                       size_t *length)
 294 {
 295     krb5_error_code ret;
 296     krb5_crypto crypto;
 297     krb5_keyblock key;
 298
 299     ret = krb5_generate_random_keyblock(context, enctype, &key);
 300     if (ret)
 301         return ret;
 302
 303     ret = krb5_crypto_init(context, &key, 0, &crypto);
 304     krb5_free_keyblock_contents(context, &key);
 305     if (ret)
 306         return ret;
 307
 308     *length = krb5_get_wrapped_length(context, crypto, inputlen);
 309     krb5_crypto_destroy(context, crypto);
 310
 311     return 0;
 312 }
 313
 314 /**
 315  * Deprecated: keytypes doesn't exists, they are really enctypes.
 316  *
 317  * @ingroup krb5_deprecated
 318  */
 319
 320 krb5_error_code KRB5_LIB_FUNCTION
 321 krb5_c_enctype_compare(krb5_context context,
 322                        krb5_enctype e1,
 323                        krb5_enctype e2,
 324                        krb5_boolean *similar)
 325     KRB5_DEPRECATED
 326 {
 327     *similar = (e1 == e2);
 328     return 0;
 329 }
 330
 331 krb5_error_code KRB5_LIB_FUNCTION
 332 krb5_c_make_random_key(krb5_context context,
 333                        krb5_enctype enctype,
 334                        krb5_keyblock *random_key)
 335 {
 336     return krb5_generate_random_keyblock(context, enctype, random_key);
 337 }
 338
 339 krb5_error_code KRB5_LIB_FUNCTION
 340 krb5_c_keylengths(krb5_context context,
 341                   krb5_enctype enctype,
 342                   size_t *ilen,
 343                   size_t *keylen)
 344 {
 345     krb5_error_code ret;
 346
 347     ret = krb5_enctype_keybits(context, enctype, ilen);
 348     if (ret)
 349         return ret;
 350     *ilen = (*ilen + 7) / 8;
 351     return krb5_enctype_keysize(context, enctype, keylen);
 352 }
 353
 354 krb5_error_code KRB5_LIB_FUNCTION
 355 krb5_c_prf_length(krb5_context context,
 356                   krb5_enctype type,
 357                   size_t *length)
 358 {
 359     return krb5_crypto_prf_length(context, type, length);
 360 }
 361
 362 krb5_error_code KRB5_LIB_FUNCTION
 363 krb5_c_prf(krb5_context context,
 364            const krb5_keyblock *key,
 365            const krb5_data *input,
 366            krb5_data *output)
 367 {
 368     krb5_crypto crypto;
 369     krb5_error_code ret;
 370
 371     ret = krb5_crypto_init(context, key, 0, &crypto);
 372     if (ret)
 373         return ret;
 374
 375     ret = krb5_crypto_prf(context, crypto, input, output);
 376     krb5_crypto_destroy(context, crypto);
 377
 378     return ret;
 379 }
 380
 381 /**
 382  * MIT compat glue
 383  *
 384  * @ingroup krb5_ccache
 385  */
 386
 387 krb5_error_code KRB5_LIB_FUNCTION
 388 krb5_cc_copy_creds(krb5_context context,
 389                    const krb5_ccache from,
 390                    krb5_ccache to)
 391 {
 392     return krb5_cc_copy_cache(context, from, to);
 393 }
 394
 395 #endif /* HEIMDAL_SMALLER */