lib/hcrypto/evp.c

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