lib/hcrypto/evp.c

   1 /*
   2  * Copyright (c) 2006 - 2007 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 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  37
  38 RCSID("$Id$");
  39
  40 #include <sys/types.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <assert.h>
  45
  46 #include <evp.h>
  47
  48 #include <krb5-types.h>
  49
  50 #include <aes.h>
  51 #include "camellia.h"
  52 #include <des.h>
  53 #include <sha.h>
  54 #include <rc2.h>
  55 #include <rc4.h>
  56 #include <md2.h>
  57 #include <md4.h>
  58 #include <md5.h>
  59
  60 /**
  61  * @page page_evp EVP - generic crypto interface
  62  *
  63  * See the library functions here: @ref hcrypto_evp
  64  */
  65
  66
  67 typedef int (*evp_md_init)(EVP_MD_CTX *);
  68 typedef int (*evp_md_update)(EVP_MD_CTX *,const void *, size_t);
  69 typedef int (*evp_md_final)(void *, EVP_MD_CTX *);
  70 typedef int (*evp_md_cleanup)(EVP_MD_CTX *);
  71
  72 struct hc_evp_md {
  73     int hash_size;
  74     int block_size;
  75     int ctx_size;
  76     evp_md_init init;
  77     evp_md_update update;
  78     evp_md_final final;
  79     evp_md_cleanup cleanup;
  80 };
  81
  82 /**
  83  * Return the output size of the message digest function.
  84  *
  85  * @param md the evp message
  86  *
  87  * @return size output size of the message digest function.
  88  *
  89  * @ingroup hcrypto_evp
  90  */
  91
  92 size_t
  93 EVP_MD_size(const EVP_MD *md)
  94 {
  95     return md->hash_size;
  96 }
  97
  98 /**
  99  * Return the blocksize of the message digest function.
 100  *
 101  * @param md the evp message
 102  *
 103  * @return size size of the message digest block size
 104  *
 105  * @ingroup hcrypto_evp
 106  */
 107
 108 size_t
 109 EVP_MD_block_size(const EVP_MD *md)
 110 {
 111     return md->block_size;
 112 }
 113
 114 /**
 115  * Allocate a messsage digest context object. Free with
 116  * EVP_MD_CTX_destroy().
 117  *
 118  * @return a newly allocated message digest context object.
 119  *
 120  * @ingroup hcrypto_evp
 121  */
 122
 123 EVP_MD_CTX *
 124 EVP_MD_CTX_create(void)
 125 {
 126     return calloc(1, sizeof(EVP_MD_CTX));
 127 }
 128
 129 /**
 130  * Initiate a messsage digest context object. Deallocate with
 131  * EVP_MD_CTX_cleanup(). Please use EVP_MD_CTX_create() instead.
 132  *
 133  * @param ctx variable to initiate.
 134  *
 135  * @ingroup hcrypto_evp
 136  */
 137
 138 void
 139 EVP_MD_CTX_init(EVP_MD_CTX *ctx)
 140 {
 141     memset(ctx, 0, sizeof(*ctx));
 142 }
 143
 144 /**
 145  * Free a messsage digest context object.
 146  *
 147  * @param ctx context to free.
 148  *
 149  * @ingroup hcrypto_evp
 150  */
 151
 152 void
 153 EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
 154 {
 155     EVP_MD_CTX_cleanup(ctx);
 156     free(ctx);
 157 }
 158
 159 /**
 160  * Free the resources used by the EVP_MD context.
 161  *
 162  * @param ctx the context to free the resources from.
 163  *
 164  * @return 1 on success.
 165  *
 166  * @ingroup hcrypto_evp
 167  */
 168
 169 int
 170 EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
 171 {
 172     if (ctx->md && ctx->md->cleanup)
 173         (ctx->md->cleanup)(ctx);
 174     ctx->md = NULL;
 175     ctx->engine = NULL;
 176     free(ctx->ptr);
 177     memset(ctx, 0, sizeof(*ctx));
 178     return 1;
 179 }
 180
 181 /**
 182  * Get the EVP_MD use for a specified context.
 183  *
 184  * @param ctx the EVP_MD context to get the EVP_MD for.
 185  *
 186  * @return the EVP_MD used for the context.
 187  *
 188  * @ingroup hcrypto_evp
 189  */
 190
 191 const EVP_MD *
 192 EVP_MD_CTX_md(EVP_MD_CTX *ctx)
 193 {
 194     return ctx->md;
 195 }
 196
 197 /**
 198  * Return the output size of the message digest function.
 199  *
 200  * @param ctx the evp message digest context
 201  *
 202  * @return size output size of the message digest function.
 203  *
 204  * @ingroup hcrypto_evp
 205  */
 206
 207 size_t
 208 EVP_MD_CTX_size(EVP_MD_CTX *ctx)
 209 {
 210     return EVP_MD_size(ctx->md);
 211 }
 212
 213 /**
 214  * Return the blocksize of the message digest function.
 215  *
 216  * @param ctx the evp message digest context
 217  *
 218  * @return size size of the message digest block size
 219  *
 220  * @ingroup hcrypto_evp
 221  */
 222
 223 size_t
 224 EVP_MD_CTX_block_size(EVP_MD_CTX *ctx)
 225 {
 226     return EVP_MD_block_size(ctx->md);
 227 }
 228
 229 /**
 230  * Init a EVP_MD_CTX for use a specific message digest and engine.
 231  *
 232  * @param ctx the message digest context to init.
 233  * @param md the message digest to use.
 234  * @param engine the engine to use, NULL to use the default engine.
 235  *
 236  * @return 1 on success.
 237  *
 238  * @ingroup hcrypto_evp
 239  */
 240
 241 int
 242 EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *md, ENGINE *engine)
 243 {
 244     if (ctx->md != md || ctx->engine != engine) {
 245         EVP_MD_CTX_cleanup(ctx);
 246         ctx->md = md;
 247         ctx->engine = engine;
 248
 249         ctx->ptr = calloc(1, md->ctx_size);
 250         if (ctx->ptr == NULL)
 251             return 0;
 252     }
 253     (ctx->md->init)(ctx->ptr);
 254     return 1;
 255 }
 256
 257 int
 258 EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t size)
 259 {
 260     (ctx->md->update)(ctx->ptr, data, size);
 261     return 1;
 262 }
 263
 264 int
 265 EVP_DigestFinal_ex(EVP_MD_CTX *ctx, void *hash, unsigned int *size)
 266 {
 267     (ctx->md->final)(hash, ctx->ptr);
 268     if (size)
 269         *size = ctx->md->hash_size;
 270     return 1;
 271 }
 272
 273 int
 274 EVP_Digest(const void *data, size_t dsize, void *hash, unsigned int *hsize,
 275            const EVP_MD *md, ENGINE *engine)
 276 {
 277     EVP_MD_CTX *ctx;
 278     int ret;
 279
 280     ctx = EVP_MD_CTX_create();
 281     if (ctx == NULL)
 282         return 0;
 283     ret = EVP_DigestInit_ex(ctx, md, engine);
 284     if (ret != 1)
 285         return ret;
 286     ret = EVP_DigestUpdate(ctx, data, dsize);
 287     if (ret != 1)
 288         return ret;
 289     ret = EVP_DigestFinal_ex(ctx, hash, hsize);
 290     if (ret != 1)
 291         return ret;
 292     EVP_MD_CTX_destroy(ctx);
 293     return 1;
 294 }
 295
 296 /*
 297  *
 298  */
 299
 300 const EVP_MD *
 301 EVP_sha256(void)
 302 {
 303     static const struct hc_evp_md sha256 = {
 304         32,
 305         64,
 306         sizeof(SHA256_CTX),
 307         (evp_md_init)SHA256_Init,
 308         (evp_md_update)SHA256_Update,
 309         (evp_md_final)SHA256_Final,
 310         NULL
 311     };
 312     return &sha256;
 313 }
 314
 315 static const struct hc_evp_md sha1 = {
 316     20,
 317     64,
 318     sizeof(SHA_CTX),
 319     (evp_md_init)SHA1_Init,
 320     (evp_md_update)SHA1_Update,
 321     (evp_md_final)SHA1_Final,
 322     NULL
 323 };
 324
 325 const EVP_MD *
 326 EVP_sha1(void)
 327 {
 328     return &sha1;
 329 }
 330
 331 const EVP_MD *
 332 EVP_sha(void)
 333 {
 334     return &sha1;
 335 }
 336
 337 const EVP_MD *
 338 EVP_md5(void)
 339 {
 340     static const struct hc_evp_md md5 = {
 341         16,
 342         64,
 343         sizeof(MD5_CTX),
 344         (evp_md_init)MD5_Init,
 345         (evp_md_update)MD5_Update,
 346         (evp_md_final)MD5_Final,
 347         NULL
 348     };
 349     return &md5;
 350 }
 351
 352 const EVP_MD *
 353 EVP_md4(void)
 354 {
 355     static const struct hc_evp_md md4 = {
 356         16,
 357         64,
 358         sizeof(MD4_CTX),
 359         (evp_md_init)MD4_Init,
 360         (evp_md_update)MD4_Update,
 361         (evp_md_final)MD4_Final,
 362         NULL
 363     };
 364     return &md4;
 365 }
 366
 367 const EVP_MD *
 368 EVP_md2(void)
 369 {
 370     static const struct hc_evp_md md2 = {
 371         16,
 372         16,
 373         sizeof(MD2_CTX),
 374         (evp_md_init)MD2_Init,
 375         (evp_md_update)MD2_Update,
 376         (evp_md_final)MD2_Final,
 377         NULL
 378     };
 379     return &md2;
 380 }
 381
 382 /*
 383  *
 384  */
 385
 386 static void
 387 null_Init (void *m)
 388 {
 389 }
 390 static void
 391 null_Update (void *m, const void * data, size_t size)
 392 {
 393 }
 394 static void
 395 null_Final(void *res, struct md5 *m)
 396 {
 397 }
 398
 399 const EVP_MD *
 400 EVP_md_null(void)
 401 {
 402     static const struct hc_evp_md null = {
 403         0,
 404         0,
 405         0,
 406         (evp_md_init)null_Init,
 407         (evp_md_update)null_Update,
 408         (evp_md_final)null_Final,
 409         NULL
 410     };
 411     return &null;
 412 }
 413
 414 #if 0
 415 void    EVP_MD_CTX_init(EVP_MD_CTX *ctx);
 416 int     EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
 417 int     EVP_DigestFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
 418 int     EVP_SignFinal(EVP_MD_CTX *, void *, size_t *, EVP_PKEY *);
 419 int     EVP_VerifyFinal(EVP_MD_CTX *, const void *, size_t, EVP_PKEY *);
 420 #endif
 421
 422 /*
 423  *
 424  */
 425
 426 size_t
 427 EVP_CIPHER_block_size(const EVP_CIPHER *c)
 428 {
 429     return c->block_size;
 430 }
 431
 432 size_t
 433 EVP_CIPHER_key_length(const EVP_CIPHER *c)
 434 {
 435     return c->key_len;
 436 }
 437
 438 size_t
 439 EVP_CIPHER_iv_length(const EVP_CIPHER *c)
 440 {
 441     return c->iv_len;
 442 }
 443
 444 void
 445 EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *c)
 446 {
 447     memset(c, 0, sizeof(*c));
 448 }
 449
 450 int
 451 EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
 452 {
 453     if (c->cipher && c->cipher->cleanup)
 454         c->cipher->cleanup(c);
 455     if (c->cipher_data) {
 456         free(c->cipher_data);
 457         c->cipher_data = NULL;
 458     }
 459     return 1;
 460 }
 461
 462 #if 0
 463 int
 464 EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int length)
 465 {
 466     return 0;
 467 }
 468
 469 int
 470 EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad)
 471 {
 472     return 0;
 473 }
 474 #endif
 475
 476 const EVP_CIPHER *
 477 EVP_CIPHER_CTX_cipher(EVP_CIPHER_CTX *ctx)
 478 {
 479     return ctx->cipher;
 480 }
 481
 482 size_t
 483 EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
 484 {
 485     return EVP_CIPHER_block_size(ctx->cipher);
 486 }
 487
 488 size_t
 489 EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
 490 {
 491     return EVP_CIPHER_key_length(ctx->cipher);
 492 }
 493
 494 size_t
 495 EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
 496 {
 497     return EVP_CIPHER_iv_length(ctx->cipher);
 498 }
 499
 500 unsigned long
 501 EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
 502 {
 503     return ctx->cipher->flags;
 504 }
 505
 506 int
 507 EVP_CIPHER_CTX_mode(const EVP_CIPHER_CTX *ctx)
 508 {
 509     return EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_MODE;
 510 }
 511
 512 void *
 513 EVP_CIPHER_CTX_get_app_data(EVP_CIPHER_CTX *ctx)
 514 {
 515     return ctx->app_data;
 516 }
 517
 518 void
 519 EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
 520 {
 521     ctx->app_data = data;
 522 }
 523
 524 int
 525 EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *c, ENGINE *engine,
 526                   const void *key, const void *iv, int encp)
 527 {
 528     if (encp == -1)
 529         encp = ctx->encrypt;
 530     else
 531         ctx->encrypt = (encp ? 1 : 0);
 532
 533     if (c && (c != ctx->cipher)) {
 534         EVP_CIPHER_CTX_cleanup(ctx);
 535         ctx->cipher = c;
 536         ctx->key_len = c->key_len;
 537
 538         ctx->cipher_data = malloc(c->ctx_size);
 539         if (ctx->cipher_data == NULL && c->ctx_size != 0)
 540             return 0;
 541
 542     } else if (ctx->cipher == NULL) {
 543         /* reuse of cipher, but not any cipher ever set! */
 544         return 0;
 545     }
 546
 547     switch (EVP_CIPHER_CTX_flags(ctx)) {
 548     case EVP_CIPH_CBC_MODE:
 549
 550         assert(EVP_CIPHER_CTX_iv_length(ctx) <= sizeof(ctx->iv));
 551
 552         if (iv)
 553             memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
 554         memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
 555         break;
 556     default:
 557         return 0;
 558     }
 559
 560     if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT))
 561         ctx->cipher->init(ctx, key, iv, encp);
 562
 563     return 1;
 564 }
 565
 566 int
 567 EVP_Cipher(EVP_CIPHER_CTX *ctx, void *out, const void *in,size_t size)
 568 {
 569     return ctx->cipher->do_cipher(ctx, out, in, size);
 570 }
 571
 572 /*
 573  *
 574  */
 575
 576 static int
 577 enc_null_init(EVP_CIPHER_CTX *ctx,
 578                   const unsigned char * key,
 579                   const unsigned char * iv,
 580                   int encp)
 581 {
 582     return 1;
 583 }
 584
 585 static int
 586 enc_null_do_cipher(EVP_CIPHER_CTX *ctx,
 587               unsigned char *out,
 588               const unsigned char *in,
 589               unsigned int size)
 590 {
 591     memmove(out, in, size);
 592     return 1;
 593 }
 594
 595 static int
 596 enc_null_cleanup(EVP_CIPHER_CTX *ctx)
 597 {
 598     return 1;
 599 }
 600
 601 const EVP_CIPHER *
 602 EVP_enc_null(void)
 603 {
 604     static const EVP_CIPHER enc_null = {
 605         0,
 606         0,
 607         0,
 608         0,
 609         EVP_CIPH_CBC_MODE,
 610         enc_null_init,
 611         enc_null_do_cipher,
 612         enc_null_cleanup,
 613         0,
 614         NULL,
 615         NULL,
 616         NULL,
 617         NULL
 618     };
 619     return &enc_null;
 620 }
 621
 622 /*
 623  *
 624  */
 625
 626 struct rc2_cbc {
 627     unsigned int maximum_effective_key;
 628     RC2_KEY key;
 629 };
 630
 631 static int
 632 rc2_init(EVP_CIPHER_CTX *ctx,
 633          const unsigned char * key,
 634          const unsigned char * iv,
 635          int encp)
 636 {
 637     struct rc2_cbc *k = ctx->cipher_data;
 638     k->maximum_effective_key = EVP_CIPHER_CTX_key_length(ctx) * 8;
 639     RC2_set_key(&k->key,
 640                 EVP_CIPHER_CTX_key_length(ctx),
 641                 key,
 642                 k->maximum_effective_key);
 643     return 1;
 644 }
 645
 646 static int
 647 rc2_do_cipher(EVP_CIPHER_CTX *ctx,
 648               unsigned char *out,
 649               const unsigned char *in,
 650               unsigned int size)
 651 {
 652     struct rc2_cbc *k = ctx->cipher_data;
 653     RC2_cbc_encrypt(in, out, size, &k->key, ctx->iv, ctx->encrypt);
 654     return 1;
 655 }
 656
 657 static int
 658 rc2_cleanup(EVP_CIPHER_CTX *ctx)
 659 {
 660     memset(ctx->cipher_data, 0, sizeof(struct rc2_cbc));
 661     return 1;
 662 }
 663
 664
 665 const EVP_CIPHER *
 666 EVP_rc2_cbc(void)
 667 {
 668     static const EVP_CIPHER rc2_cbc = {
 669         0,
 670         RC2_BLOCK_SIZE,
 671         RC2_KEY_LENGTH,
 672         RC2_BLOCK_SIZE,
 673         EVP_CIPH_CBC_MODE,
 674         rc2_init,
 675         rc2_do_cipher,
 676         rc2_cleanup,
 677         sizeof(struct rc2_cbc),
 678         NULL,
 679         NULL,
 680         NULL,
 681         NULL
 682     };
 683     return &rc2_cbc;
 684 }
 685
 686 const EVP_CIPHER *
 687 EVP_rc2_40_cbc(void)
 688 {
 689     static const EVP_CIPHER rc2_40_cbc = {
 690         0,
 691         RC2_BLOCK_SIZE,
 692         5,
 693         RC2_BLOCK_SIZE,
 694         EVP_CIPH_CBC_MODE,
 695         rc2_init,
 696         rc2_do_cipher,
 697         rc2_cleanup,
 698         sizeof(struct rc2_cbc),
 699         NULL,
 700         NULL,
 701         NULL,
 702         NULL
 703     };
 704     return &rc2_40_cbc;
 705 }
 706
 707 const EVP_CIPHER *
 708 EVP_rc2_64_cbc(void)
 709 {
 710     static const EVP_CIPHER rc2_64_cbc = {
 711         0,
 712         RC2_BLOCK_SIZE,
 713         8,
 714         RC2_BLOCK_SIZE,
 715         EVP_CIPH_CBC_MODE,
 716         rc2_init,
 717         rc2_do_cipher,
 718         rc2_cleanup,
 719         sizeof(struct rc2_cbc),
 720         NULL,
 721         NULL,
 722         NULL,
 723         NULL
 724     };
 725     return &rc2_64_cbc;
 726 }
 727
 728 /*
 729  *
 730  */
 731
 732 const EVP_CIPHER *
 733 EVP_rc4(void)
 734 {
 735     printf("evp rc4\n");
 736     abort();
 737     return NULL;
 738 }
 739
 740 const EVP_CIPHER *
 741 EVP_rc4_40(void)
 742 {
 743     printf("evp rc4_40\n");
 744     abort();
 745     return NULL;
 746 }
 747
 748 /*
 749  *
 750  */
 751
 752 struct des_ede3_cbc {
 753     DES_key_schedule ks[3];
 754 };
 755
 756 static int
 757 des_ede3_cbc_init(EVP_CIPHER_CTX *ctx,
 758                   const unsigned char * key,
 759                   const unsigned char * iv,
 760                   int encp)
 761 {
 762     struct des_ede3_cbc *k = ctx->cipher_data;
 763
 764     DES_key_sched((DES_cblock *)(key), &k->ks[0]);
 765     DES_key_sched((DES_cblock *)(key + 8), &k->ks[1]);
 766     DES_key_sched((DES_cblock *)(key + 16), &k->ks[2]);
 767
 768     return 1;
 769 }
 770
 771 static int
 772 des_ede3_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
 773                        unsigned char *out,
 774                        const unsigned char *in,
 775                        unsigned int size)
 776 {
 777     struct des_ede3_cbc *k = ctx->cipher_data;
 778     DES_ede3_cbc_encrypt(in, out, size,
 779                          &k->ks[0], &k->ks[1], &k->ks[2],
 780                          (DES_cblock *)ctx->iv, ctx->encrypt);
 781     return 1;
 782 }
 783
 784 static int
 785 des_ede3_cbc_cleanup(EVP_CIPHER_CTX *ctx)
 786 {
 787     memset(ctx->cipher_data, 0, sizeof(struct des_ede3_cbc));
 788     return 1;
 789 }
 790
 791 const EVP_CIPHER *
 792 EVP_des_ede3_cbc(void)
 793 {
 794     static const EVP_CIPHER des_ede3_cbc = {
 795         0,
 796         8,
 797         24,
 798         8,
 799         EVP_CIPH_CBC_MODE,
 800         des_ede3_cbc_init,
 801         des_ede3_cbc_do_cipher,
 802         des_ede3_cbc_cleanup,
 803         sizeof(struct des_ede3_cbc),
 804         NULL,
 805         NULL,
 806         NULL,
 807         NULL
 808     };
 809     return &des_ede3_cbc;
 810 }
 811
 812 /*
 813  *
 814  */
 815
 816 static int
 817 aes_init(EVP_CIPHER_CTX *ctx,
 818          const unsigned char * key,
 819          const unsigned char * iv,
 820          int encp)
 821 {
 822     AES_KEY *k = ctx->cipher_data;
 823     if (ctx->encrypt)
 824         AES_set_encrypt_key(key, ctx->cipher->key_len * 8, k);
 825     else
 826         AES_set_decrypt_key(key, ctx->cipher->key_len * 8, k);
 827     return 1;
 828 }
 829
 830 static int
 831 aes_do_cipher(EVP_CIPHER_CTX *ctx,
 832               unsigned char *out,
 833               const unsigned char *in,
 834               unsigned int size)
 835 {
 836     AES_KEY *k = ctx->cipher_data;
 837     AES_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
 838     return 1;
 839 }
 840
 841 static int
 842 aes_cleanup(EVP_CIPHER_CTX *ctx)
 843 {
 844     memset(ctx->cipher_data, 0, sizeof(AES_KEY));
 845     return 1;
 846 }
 847
 848 const EVP_CIPHER *
 849 EVP_aes_128_cbc(void)
 850 {
 851     static const EVP_CIPHER aes_128_cbc = {
 852         0,
 853         16,
 854         16,
 855         16,
 856         EVP_CIPH_CBC_MODE,
 857         aes_init,
 858         aes_do_cipher,
 859         aes_cleanup,
 860         sizeof(AES_KEY),
 861         NULL,
 862         NULL,
 863         NULL,
 864         NULL
 865     };
 866     return &aes_128_cbc;
 867 }
 868
 869 const EVP_CIPHER *
 870 EVP_aes_192_cbc(void)
 871 {
 872     static const EVP_CIPHER aes_192_cbc = {
 873         0,
 874         16,
 875         24,
 876         16,
 877         EVP_CIPH_CBC_MODE,
 878         aes_init,
 879         aes_do_cipher,
 880         aes_cleanup,
 881         sizeof(AES_KEY),
 882         NULL,
 883         NULL,
 884         NULL,
 885         NULL
 886     };
 887     return &aes_192_cbc;
 888 }
 889
 890
 891 const EVP_CIPHER *
 892 EVP_aes_256_cbc(void)
 893 {
 894     static const EVP_CIPHER aes_256_cbc = {
 895         0,
 896         16,
 897         32,
 898         16,
 899         EVP_CIPH_CBC_MODE,
 900         aes_init,
 901         aes_do_cipher,
 902         aes_cleanup,
 903         sizeof(AES_KEY),
 904         NULL,
 905         NULL,
 906         NULL,
 907         NULL
 908     };
 909     return &aes_256_cbc;
 910 }
 911
 912 static int
 913 camellia_init(EVP_CIPHER_CTX *ctx,
 914          const unsigned char * key,
 915          const unsigned char * iv,
 916          int encp)
 917 {
 918     CAMELLIA_KEY *k = ctx->cipher_data;
 919     k->bits = ctx->cipher->key_len * 8;
 920     CAMELLIA_set_key(key, ctx->cipher->key_len * 8, k);
 921     return 1;
 922 }
 923
 924 static int
 925 camellia_do_cipher(EVP_CIPHER_CTX *ctx,
 926               unsigned char *out,
 927               const unsigned char *in,
 928               unsigned int size)
 929 {
 930     CAMELLIA_KEY *k = ctx->cipher_data;
 931     CAMELLIA_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
 932     return 1;
 933 }
 934
 935 static int
 936 camellia_cleanup(EVP_CIPHER_CTX *ctx)
 937 {
 938     memset(ctx->cipher_data, 0, sizeof(CAMELLIA_KEY));
 939     return 1;
 940 }
 941
 942 const EVP_CIPHER *
 943 EVP_camellia_128_cbc(void)
 944 {
 945     static const EVP_CIPHER cipher = {
 946         0,
 947         16,
 948         16,
 949         16,
 950         EVP_CIPH_CBC_MODE,
 951         camellia_init,
 952         camellia_do_cipher,
 953         camellia_cleanup,
 954         sizeof(CAMELLIA_KEY),
 955         NULL,
 956         NULL,
 957         NULL,
 958         NULL
 959     };
 960     return &cipher;
 961 }
 962
 963 const EVP_CIPHER *
 964 EVP_camellia_192_cbc(void)
 965 {
 966     static const EVP_CIPHER cipher = {
 967         0,
 968         16,
 969         24,
 970         16,
 971         EVP_CIPH_CBC_MODE,
 972         camellia_init,
 973         camellia_do_cipher,
 974         camellia_cleanup,
 975         sizeof(CAMELLIA_KEY),
 976         NULL,
 977         NULL,
 978         NULL,
 979         NULL
 980     };
 981     return &cipher;
 982 }
 983
 984 const EVP_CIPHER *
 985 EVP_camellia_256_cbc(void)
 986 {
 987     static const EVP_CIPHER cipher = {
 988         0,
 989         16,
 990         32,
 991         16,
 992         EVP_CIPH_CBC_MODE,
 993         camellia_init,
 994         camellia_do_cipher,
 995         camellia_cleanup,
 996         sizeof(CAMELLIA_KEY),
 997         NULL,
 998         NULL,
 999         NULL,
1000         NULL
1001     };
1002     return &cipher;
1003 }
1004
1005 /*
1006  *
1007  */
1008
1009 static const struct cipher_name {
1010     const char *name;
1011     const EVP_CIPHER *(*func)(void);
1012 } cipher_name[] = {
1013     { "des-ede3-cbc", EVP_des_ede3_cbc },
1014     { "aes-128-cbc", EVP_aes_128_cbc },
1015     { "aes-192-cbc", EVP_aes_192_cbc },
1016     { "aes-256-cbc", EVP_aes_256_cbc },
1017     { "camellia-128-cbc", EVP_camellia_128_cbc },
1018     { "camellia-192-cbc", EVP_camellia_192_cbc },
1019     { "camellia-256-cbc", EVP_camellia_256_cbc }
1020 };
1021
1022
1023 const EVP_CIPHER *
1024 EVP_get_cipherbyname(const char *name)
1025 {
1026     int i;
1027     for (i = 0; i < sizeof(cipher_name)/sizeof(cipher_name[0]); i++) {
1028         if (strcasecmp(cipher_name[i].name, name) == 0)
1029             return (*cipher_name[i].func)();
1030     }
1031     return NULL;
1032 }
1033
1034
1035 /*
1036  *
1037  */
1038
1039 #ifndef min
1040 #define min(a,b) (((a)>(b))?(b):(a))
1041 #endif
1042
1043 int
1044 EVP_BytesToKey(const EVP_CIPHER *type,
1045                const EVP_MD *md,
1046                const void *salt,
1047                const void *data, size_t datalen,
1048                unsigned int count,
1049                void *keydata,
1050                void *ivdata)
1051 {
1052     int ivlen, keylen, first = 0;
1053     unsigned int mds = 0, i;
1054     unsigned char *key = keydata;
1055     unsigned char *iv = ivdata;
1056     unsigned char *buf;
1057     EVP_MD_CTX c;
1058
1059     keylen = EVP_CIPHER_key_length(type);
1060     ivlen = EVP_CIPHER_iv_length(type);
1061
1062     if (data == NULL)
1063         return keylen;
1064
1065     buf = malloc(EVP_MD_size(md));
1066     if (buf == NULL)
1067         return -1;
1068
1069     EVP_MD_CTX_init(&c);
1070
1071     first = 1;
1072     while (1) {
1073         EVP_DigestInit_ex(&c, md, NULL);
1074         if (!first)
1075             EVP_DigestUpdate(&c, buf, mds);
1076         first = 0;
1077         EVP_DigestUpdate(&c,data,datalen);
1078
1079 #define PKCS5_SALT_LEN 8
1080
1081         if (salt)
1082             EVP_DigestUpdate(&c, salt, PKCS5_SALT_LEN);
1083
1084         EVP_DigestFinal_ex(&c, buf, &mds);
1085         assert(mds == EVP_MD_size(md));
1086
1087         for (i = 1; i < count; i++) {
1088             EVP_DigestInit_ex(&c, md, NULL);
1089             EVP_DigestUpdate(&c, buf, mds);
1090             EVP_DigestFinal_ex(&c, buf, &mds);
1091             assert(mds == EVP_MD_size(md));
1092         }
1093
1094         i = 0;
1095         if (keylen) {
1096             size_t sz = min(keylen, mds);
1097             if (key) {
1098                 memcpy(key, buf, sz);
1099                 key += sz;
1100             }
1101             keylen -= sz;
1102             i += sz;
1103         }
1104         if (ivlen && mds > i) {
1105             size_t sz = min(ivlen, (mds - i));
1106             if (iv) {
1107                 memcpy(iv, &buf[i], sz);
1108                 iv += sz;
1109             }
1110             ivlen -= sz;
1111         }
1112         if (keylen == 0 && ivlen == 0)
1113             break;
1114     }
1115
1116     EVP_MD_CTX_cleanup(&c);
1117     free(buf);
1118
1119     return EVP_CIPHER_key_length(type);
1120 }
1121
1122 /*
1123  *
1124  */
1125
1126 void
1127 OpenSSL_add_all_algorithms(void)
1128 {
1129     return;
1130 }
1131
1132 void
1133 OpenSSL_add_all_algorithms_conf(void)
1134 {
1135     return;
1136 }
1137
1138 void
1139 OpenSSL_add_all_algorithms_noconf(void)
1140 {
1141     return;
1142 }