source4/heimdal/lib/des/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 struct hc_evp_md {
  21     int hash_size;
  22     int block_size;
  23     int ctx_size;
  24     int (*init)(EVP_MD_CTX *);
  25     int (*update)(EVP_MD_CTX *,const void *, size_t );
  26     int (*final)(void *, EVP_MD_CTX *);
  27     int (*cleanup)(EVP_MD_CTX *);
  28 };
  29
  30 /*
  31  *
  32  */
  33
  34 size_t
  35 EVP_MD_size(const EVP_MD *md)
  36 {
  37     return md->hash_size;
  38 }
  39
  40 size_t
  41 EVP_MD_block_size(const EVP_MD *md)
  42 {
  43     return md->block_size;
  44 }
  45
  46 EVP_MD_CTX *
  47 EVP_MD_CTX_create(void)
  48 {
  49     return calloc(1, sizeof(EVP_MD_CTX));
  50 }
  51
  52 void
  53 EVP_MD_CTX_init(EVP_MD_CTX *ctx)
  54 {
  55     memset(ctx, 0, sizeof(*ctx));
  56 }
  57
  58 void
  59 EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
  60 {
  61     EVP_MD_CTX_cleanup(ctx);
  62     free(ctx);
  63 }
  64
  65 int
  66 EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
  67 {
  68     if (ctx->md && ctx->md->cleanup)
  69         (ctx->md->cleanup)(ctx);
  70     ctx->md = NULL;
  71     ctx->engine = NULL;
  72     free(ctx->ptr);
  73     return 1;
  74 }
  75
  76
  77 const EVP_MD *
  78 EVP_MD_CTX_md(EVP_MD_CTX *ctx)
  79 {
  80     return ctx->md;
  81 }
  82
  83 size_t
  84 EVP_MD_CTX_size(EVP_MD_CTX *ctx)
  85 {
  86     return EVP_MD_size(ctx->md);
  87 }
  88
  89 size_t
  90 EVP_MD_CTX_block_size(EVP_MD_CTX *ctx)
  91 {
  92     return EVP_MD_block_size(ctx->md);
  93 }
  94
  95 int
  96 EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *md, ENGINE *engine)
  97 {
  98     if (ctx->md != md || ctx->engine != engine) {
  99         EVP_MD_CTX_cleanup(ctx);
 100         ctx->md = md;
 101         ctx->engine = engine;
 102
 103         ctx->ptr = calloc(1, md->ctx_size);
 104         if (ctx->ptr == NULL)
 105             return 0;
 106     }
 107     (ctx->md->init)(ctx->ptr);
 108     return 1;
 109 }
 110
 111 int
 112 EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t size)
 113 {
 114     (ctx->md->update)(ctx->ptr, data, size);
 115     return 1;
 116 }
 117
 118 int
 119 EVP_DigestFinal_ex(EVP_MD_CTX *ctx, void *hash, unsigned int *size)
 120 {
 121     (ctx->md->final)(hash, ctx->ptr);
 122     if (size)
 123         *size = ctx->md->hash_size;
 124     return 1;
 125 }
 126
 127 int
 128 EVP_Digest(const void *data, size_t dsize, void *hash, unsigned int *hsize,
 129            const EVP_MD *md, ENGINE *engine)
 130 {
 131     EVP_MD_CTX *ctx;
 132     int ret;
 133
 134     ctx = EVP_MD_CTX_create();
 135     if (ctx == NULL)
 136         return 0;
 137     ret = EVP_DigestInit_ex(ctx, md, engine);
 138     if (ret != 1)
 139         return ret;
 140     ret = EVP_DigestUpdate(ctx, data, dsize);
 141     if (ret != 1)
 142         return ret;
 143     ret = EVP_DigestFinal_ex(ctx, hash, hsize);
 144     if (ret != 1)
 145         return ret;
 146     EVP_MD_CTX_destroy(ctx);
 147     return 1;
 148 }
 149
 150 /*
 151  *
 152  */
 153
 154 static const struct hc_evp_md sha1 = {
 155     20,
 156     64,
 157     sizeof(SHA_CTX),
 158     (void *)SHA1_Init,
 159     (void *)SHA1_Update,
 160     (void *)SHA1_Final,
 161     NULL
 162 };
 163
 164 const EVP_MD *
 165 EVP_sha1(void)
 166 {
 167     return &sha1;
 168 }
 169
 170 const EVP_MD *
 171 EVP_sha(void)
 172 {
 173     return &sha1;
 174 }
 175
 176 const EVP_MD *
 177 EVP_md5(void)
 178 {
 179     static const struct hc_evp_md md5 = {
 180         16,
 181         64,
 182         sizeof(MD5_CTX),
 183         (void *)MD5_Init,
 184         (void *)MD5_Update,
 185         (void *)MD5_Final,
 186         NULL
 187     };
 188     return &md5;
 189 }
 190
 191 const EVP_MD *
 192 EVP_md4(void)
 193 {
 194     static const struct hc_evp_md md4 = {
 195         16,
 196         64,
 197         sizeof(MD4_CTX),
 198         (void *)MD4_Init,
 199         (void *)MD4_Update,
 200         (void *)MD4_Final,
 201         NULL
 202     };
 203     return &md4;
 204 }
 205
 206 const EVP_MD *
 207 EVP_md2(void)
 208 {
 209     static const struct hc_evp_md md2 = {
 210         16,
 211         16,
 212         sizeof(MD2_CTX),
 213         (void *)MD2_Init,
 214         (void *)MD2_Update,
 215         (void *)MD2_Final,
 216         NULL
 217     };
 218     return &md2;
 219 }
 220
 221 /*
 222  *
 223  */
 224
 225 static void
 226 null_Init (void *m)
 227 {
 228 }
 229 static void
 230 null_Update (void *m, const void * data, size_t size)
 231 {
 232 }
 233 static void
 234 null_Final(void *res, struct md5 *m)
 235 {
 236 }
 237
 238 const EVP_MD *
 239 EVP_md_null(void)
 240 {
 241     static const struct hc_evp_md null = {
 242         0,
 243         0,
 244         0,
 245         (void *)null_Init,
 246         (void *)null_Update,
 247         (void *)null_Final,
 248         NULL
 249     };
 250     return &null;
 251 }
 252
 253 #if 0
 254 void    EVP_MD_CTX_init(EVP_MD_CTX *ctx);
 255 int     EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
 256 int     EVP_DigestFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
 257 int     EVP_SignFinal(EVP_MD_CTX *, void *, size_t *, EVP_PKEY *);
 258 int     EVP_VerifyFinal(EVP_MD_CTX *, const void *, size_t, EVP_PKEY *);
 259 #endif
 260
 261 /*
 262  *
 263  */
 264
 265 size_t
 266 EVP_CIPHER_block_size(const EVP_CIPHER *c)
 267 {
 268     return c->block_size;
 269 }
 270
 271 size_t
 272 EVP_CIPHER_key_length(const EVP_CIPHER *c)
 273 {
 274     return c->key_len;
 275 }
 276
 277 size_t
 278 EVP_CIPHER_iv_length(const EVP_CIPHER *c)
 279 {
 280     return c->iv_len;
 281 }
 282
 283 void
 284 EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *c)
 285 {
 286     memset(c, 0, sizeof(*c));
 287 }
 288
 289 int
 290 EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
 291 {
 292     if (c->cipher && c->cipher->cleanup)
 293         c->cipher->cleanup(c);
 294     if (c->cipher_data) {
 295         free(c->cipher_data);
 296         c->cipher_data = NULL;
 297     }
 298     return 1;
 299 }
 300
 301 #if 0
 302 int
 303 EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int length)
 304 {
 305     return 0;
 306 }
 307
 308 int
 309 EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad)
 310 {
 311     return 0;
 312 }
 313 #endif
 314
 315 const EVP_CIPHER *
 316 EVP_CIPHER_CTX_cipher(EVP_CIPHER_CTX *ctx)
 317 {
 318     return ctx->cipher;
 319 }
 320
 321 size_t
 322 EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
 323 {
 324     return EVP_CIPHER_block_size(ctx->cipher);
 325 }
 326
 327 size_t
 328 EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
 329 {
 330     return EVP_CIPHER_key_length(ctx->cipher);
 331 }
 332
 333 size_t
 334 EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
 335 {
 336     return EVP_CIPHER_iv_length(ctx->cipher);
 337 }
 338
 339 unsigned long
 340 EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
 341 {
 342     return ctx->cipher->flags;
 343 }
 344
 345 int
 346 EVP_CIPHER_CTX_mode(const EVP_CIPHER_CTX *ctx)
 347 {
 348     return EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_MODE;
 349 }
 350
 351 void *
 352 EVP_CIPHER_CTX_get_app_data(EVP_CIPHER_CTX *ctx)
 353 {
 354     return ctx->app_data;
 355 }
 356
 357 void
 358 EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
 359 {
 360     ctx->app_data = data;
 361 }
 362
 363 int
 364 EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *c, ENGINE *engine,
 365                   const void *key, const void *iv, int encp)
 366 {
 367     if (encp == -1)
 368         encp = ctx->encrypt;
 369     else
 370         ctx->encrypt = (encp ? 1 : 0);
 371
 372     if (c && (c != ctx->cipher)) {
 373         EVP_CIPHER_CTX_cleanup(ctx);
 374         ctx->cipher = c;
 375         ctx->key_len = c->key_len;
 376
 377         ctx->cipher_data = malloc(c->ctx_size);
 378         if (ctx->cipher_data == NULL && c->ctx_size != 0)
 379             return 0;
 380
 381     } else if (ctx->cipher == NULL) {
 382         /* reuse of cipher, but not any cipher ever set! */
 383         return 0;
 384     }
 385
 386     switch (EVP_CIPHER_CTX_flags(ctx)) {
 387     case EVP_CIPH_CBC_MODE:
 388
 389         assert(EVP_CIPHER_CTX_iv_length(ctx) <= sizeof(ctx->iv));
 390
 391         if (iv)
 392             memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
 393         memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
 394         break;
 395     default:
 396         return 0;
 397     }
 398
 399     if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT))
 400         ctx->cipher->init(ctx, key, iv, encp);
 401
 402     return 1;
 403 }
 404
 405 int
 406 EVP_Cipher(EVP_CIPHER_CTX *ctx, void *out, const void *in,size_t size)
 407 {
 408     return ctx->cipher->do_cipher(ctx, out, in, size);
 409 }
 410
 411 /*
 412  *
 413  */
 414
 415 static int
 416 enc_null_init(EVP_CIPHER_CTX *ctx,
 417                   const unsigned char * key,
 418                   const unsigned char * iv,
 419                   int encp)
 420 {
 421     return 1;
 422 }
 423
 424 static int
 425 enc_null_do_cipher(EVP_CIPHER_CTX *ctx,
 426               unsigned char *out,
 427               const unsigned char *in,
 428               unsigned int size)
 429 {
 430     memmove(out, in, size);
 431     return 1;
 432 }
 433
 434 static int
 435 enc_null_cleanup(EVP_CIPHER_CTX *ctx)
 436 {
 437     return 1;
 438 }
 439
 440 const EVP_CIPHER *
 441 EVP_enc_null(void)
 442 {
 443     static const EVP_CIPHER enc_null = {
 444         0,
 445         0,
 446         0,
 447         0,
 448         EVP_CIPH_CBC_MODE,
 449         enc_null_init,
 450         enc_null_do_cipher,
 451         enc_null_cleanup,
 452         0,
 453         NULL,
 454         NULL,
 455         NULL,
 456         NULL
 457     };
 458     return &enc_null;
 459 }
 460
 461 /*
 462  *
 463  */
 464
 465 struct rc2_cbc {
 466     unsigned int maximum_effective_key;
 467     RC2_KEY key;
 468 };
 469
 470 static int
 471 rc2_init(EVP_CIPHER_CTX *ctx,
 472          const unsigned char * key,
 473          const unsigned char * iv,
 474          int encp)
 475 {
 476     struct rc2_cbc *k = ctx->cipher_data;
 477     k->maximum_effective_key = EVP_CIPHER_CTX_key_length(ctx) * 8;
 478     RC2_set_key(&k->key,
 479                 EVP_CIPHER_CTX_key_length(ctx),
 480                 key,
 481                 k->maximum_effective_key);
 482     return 1;
 483 }
 484
 485 static int
 486 rc2_do_cipher(EVP_CIPHER_CTX *ctx,
 487               unsigned char *out,
 488               const unsigned char *in,
 489               unsigned int size)
 490 {
 491     struct rc2_cbc *k = ctx->cipher_data;
 492     RC2_cbc_encrypt(in, out, size, &k->key, ctx->iv, ctx->encrypt);
 493     return 1;
 494 }
 495
 496 static int
 497 rc2_cleanup(EVP_CIPHER_CTX *ctx)
 498 {
 499     memset(ctx->cipher_data, 0, sizeof(struct rc2_cbc));
 500     return 1;
 501 }
 502
 503
 504 const EVP_CIPHER *
 505 EVP_rc2_cbc(void)
 506 {
 507     static const EVP_CIPHER rc2_cbc = {
 508         0,
 509         RC2_BLOCK_SIZE,
 510         RC2_KEY_LENGTH,
 511         RC2_BLOCK_SIZE,
 512         EVP_CIPH_CBC_MODE,
 513         rc2_init,
 514         rc2_do_cipher,
 515         rc2_cleanup,
 516         sizeof(struct rc2_cbc),
 517         NULL,
 518         NULL,
 519         NULL,
 520         NULL
 521     };
 522     return &rc2_cbc;
 523 }
 524
 525 const EVP_CIPHER *
 526 EVP_rc2_40_cbc(void)
 527 {
 528     static const EVP_CIPHER rc2_40_cbc = {
 529         0,
 530         RC2_BLOCK_SIZE,
 531         5,
 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_40_cbc;
 544 }
 545
 546 /*
 547  *
 548  */
 549
 550 const EVP_CIPHER *
 551 EVP_rc4(void)
 552 {
 553     printf("evp rc4\n");
 554     abort();
 555     return NULL;
 556 }
 557
 558 const EVP_CIPHER *
 559 EVP_rc4_40(void)
 560 {
 561     printf("evp rc4_40\n");
 562     abort();
 563     return NULL;
 564 }
 565
 566 /*
 567  *
 568  */
 569
 570 struct des_ede3_cbc {
 571     DES_key_schedule ks[3];
 572 };
 573
 574 static int
 575 des_ede3_cbc_init(EVP_CIPHER_CTX *ctx,
 576                   const unsigned char * key,
 577                   const unsigned char * iv,
 578                   int encp)
 579 {
 580     struct des_ede3_cbc *k = ctx->cipher_data;
 581
 582     DES_key_sched((DES_cblock *)(key), &k->ks[0]);
 583     DES_key_sched((DES_cblock *)(key + 8), &k->ks[1]);
 584     DES_key_sched((DES_cblock *)(key + 16), &k->ks[2]);
 585
 586     return 1;
 587 }
 588
 589 static int
 590 des_ede3_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
 591                        unsigned char *out,
 592                        const unsigned char *in,
 593                        unsigned int size)
 594 {
 595     struct des_ede3_cbc *k = ctx->cipher_data;
 596     DES_ede3_cbc_encrypt(in, out, size,
 597                          &k->ks[0], &k->ks[1], &k->ks[2],
 598                          (DES_cblock *)ctx->iv, ctx->encrypt);
 599     return 1;
 600 }
 601
 602 static int
 603 des_ede3_cbc_cleanup(EVP_CIPHER_CTX *ctx)
 604 {
 605     memset(ctx->cipher_data, 0, sizeof(struct des_ede3_cbc));
 606     return 1;
 607 }
 608
 609 const EVP_CIPHER *
 610 EVP_des_ede3_cbc(void)
 611 {
 612     static const EVP_CIPHER des_ede3_cbc = {
 613         0,
 614         8,
 615         24,
 616         8,
 617         EVP_CIPH_CBC_MODE,
 618         des_ede3_cbc_init,
 619         des_ede3_cbc_do_cipher,
 620         des_ede3_cbc_cleanup,
 621         sizeof(struct des_ede3_cbc),
 622         NULL,
 623         NULL,
 624         NULL,
 625         NULL
 626     };
 627     return &des_ede3_cbc;
 628 }
 629
 630 /*
 631  *
 632  */
 633
 634 static int
 635 aes_init(EVP_CIPHER_CTX *ctx,
 636          const unsigned char * key,
 637          const unsigned char * iv,
 638          int encp)
 639 {
 640     AES_KEY *k = ctx->cipher_data;
 641     if (ctx->encrypt)
 642         AES_set_encrypt_key(key, ctx->cipher->key_len * 8, k);
 643     else
 644         AES_set_decrypt_key(key, ctx->cipher->key_len * 8, k);
 645     return 1;
 646 }
 647
 648 static int
 649 aes_do_cipher(EVP_CIPHER_CTX *ctx,
 650               unsigned char *out,
 651               const unsigned char *in,
 652               unsigned int size)
 653 {
 654     AES_KEY *k = ctx->cipher_data;
 655     AES_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
 656     return 1;
 657 }
 658
 659 static int
 660 aes_cleanup(EVP_CIPHER_CTX *ctx)
 661 {
 662     memset(ctx->cipher_data, 0, sizeof(AES_KEY));
 663     return 1;
 664 }
 665
 666 const EVP_CIPHER *
 667 EVP_aes_128_cbc(void)
 668 {
 669     static const EVP_CIPHER aes_128_cbc = {
 670         0,
 671         16,
 672         16,
 673         16,
 674         EVP_CIPH_CBC_MODE,
 675         aes_init,
 676         aes_do_cipher,
 677         aes_cleanup,
 678         sizeof(AES_KEY),
 679         NULL,
 680         NULL,
 681         NULL,
 682         NULL
 683     };
 684     return &aes_128_cbc;
 685 }
 686
 687 const EVP_CIPHER *
 688 EVP_aes_192_cbc(void)
 689 {
 690     static const EVP_CIPHER aes_192_cbc = {
 691         0,
 692         16,
 693         24,
 694         16,
 695         EVP_CIPH_CBC_MODE,
 696         aes_init,
 697         aes_do_cipher,
 698         aes_cleanup,
 699         sizeof(AES_KEY),
 700         NULL,
 701         NULL,
 702         NULL,
 703         NULL
 704     };
 705     return &aes_192_cbc;
 706 }
 707
 708
 709 const EVP_CIPHER *
 710 EVP_aes_256_cbc(void)
 711 {
 712     static const EVP_CIPHER aes_256_cbc = {
 713         0,
 714         16,
 715         32,
 716         16,
 717         EVP_CIPH_CBC_MODE,
 718         aes_init,
 719         aes_do_cipher,
 720         aes_cleanup,
 721         sizeof(AES_KEY),
 722         NULL,
 723         NULL,
 724         NULL,
 725         NULL
 726     };
 727     return &aes_256_cbc;
 728 }