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