lib/hcrypto/evp-hcrypto.c

   1 /*
   2  * Copyright (c) 2006 - 2008 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 #include <config.h>
  35
  36 #define HC_DEPRECATED
  37
  38 #include <sys/types.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <assert.h>
  43
  44 #include <evp.h>
  45 #include <evp-hcrypto.h>
  46
  47 #include <krb5-types.h>
  48
  49 #include <des.h>
  50 #include "camellia.h"
  51 #include <aes.h>
  52
  53 #include <rc2.h>
  54 #include <rc4.h>
  55
  56 #include <sha.h>
  57 #include <md2.h>
  58 #include <md4.h>
  59 #include <md5.h>
  60
  61 /*
  62  *
  63  */
  64
  65 static int
  66 aes_init(EVP_CIPHER_CTX *ctx,
  67          const unsigned char * key,
  68          const unsigned char * iv,
  69          int encp)
  70 {
  71     AES_KEY *k = ctx->cipher_data;
  72     if (ctx->encrypt)
  73         AES_set_encrypt_key(key, ctx->cipher->key_len * 8, k);
  74     else
  75         AES_set_decrypt_key(key, ctx->cipher->key_len * 8, k);
  76     return 1;
  77 }
  78
  79 static int
  80 aes_do_cipher(EVP_CIPHER_CTX *ctx,
  81               unsigned char *out,
  82               const unsigned char *in,
  83               unsigned int size)
  84 {
  85     AES_KEY *k = ctx->cipher_data;
  86     AES_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
  87     return 1;
  88 }
  89
  90 /**
  91  * The AES-128 cipher type (hcrypto)
  92  *
  93  * @return the AES-128 EVP_CIPHER pointer.
  94  *
  95  * @ingroup hcrypto_evp
  96  */
  97
  98 const EVP_CIPHER *
  99 EVP_hcrypto_aes_128_cbc(void)
 100 {
 101     static const EVP_CIPHER aes_128_cbc = {
 102         0,
 103         16,
 104         16,
 105         16,
 106         EVP_CIPH_CBC_MODE,
 107         aes_init,
 108         aes_do_cipher,
 109         NULL,
 110         sizeof(AES_KEY),
 111         NULL,
 112         NULL,
 113         NULL,
 114         NULL
 115     };
 116
 117     return &aes_128_cbc;
 118 }
 119
 120 /**
 121  * The AES-192 cipher type (hcrypto)
 122  *
 123  * @return the AES-192 EVP_CIPHER pointer.
 124  *
 125  * @ingroup hcrypto_evp
 126  */
 127
 128 const EVP_CIPHER *
 129 EVP_hcrypto_aes_192_cbc(void)
 130 {
 131     static const EVP_CIPHER aes_192_cbc = {
 132         0,
 133         16,
 134         24,
 135         16,
 136         EVP_CIPH_CBC_MODE,
 137         aes_init,
 138         aes_do_cipher,
 139         NULL,
 140         sizeof(AES_KEY),
 141         NULL,
 142         NULL,
 143         NULL,
 144         NULL
 145     };
 146     return &aes_192_cbc;
 147 }
 148
 149 /**
 150  * The AES-256 cipher type (hcrypto)
 151  *
 152  * @return the AES-256 EVP_CIPHER pointer.
 153  *
 154  * @ingroup hcrypto_evp
 155  */
 156
 157 const EVP_CIPHER *
 158 EVP_hcrypto_aes_256_cbc(void)
 159 {
 160     static const EVP_CIPHER aes_256_cbc = {
 161         0,
 162         16,
 163         32,
 164         16,
 165         EVP_CIPH_CBC_MODE,
 166         aes_init,
 167         aes_do_cipher,
 168         NULL,
 169         sizeof(AES_KEY),
 170         NULL,
 171         NULL,
 172         NULL,
 173         NULL
 174     };
 175     return &aes_256_cbc;
 176 }
 177
 178 /**
 179  * The message digest SHA256 - hcrypto
 180  *
 181  * @return the message digest type.
 182  *
 183  * @ingroup hcrypto_evp
 184  */
 185
 186 const EVP_MD *
 187 EVP_hcrypto_sha256(void)
 188 {
 189     static const struct hc_evp_md sha256 = {
 190         32,
 191         64,
 192         sizeof(SHA256_CTX),
 193         (hc_evp_md_init)SHA256_Init,
 194         (hc_evp_md_update)SHA256_Update,
 195         (hc_evp_md_final)SHA256_Final,
 196         NULL
 197     };
 198     return &sha256;
 199 }
 200
 201 /**
 202  * The message digest SHA1 - hcrypto
 203  *
 204  * @return the message digest type.
 205  *
 206  * @ingroup hcrypto_evp
 207  */
 208
 209 const EVP_MD *
 210 EVP_hcrypto_sha1(void)
 211 {
 212     static const struct hc_evp_md sha1 = {
 213         20,
 214         64,
 215         sizeof(SHA_CTX),
 216         (hc_evp_md_init)SHA1_Init,
 217         (hc_evp_md_update)SHA1_Update,
 218         (hc_evp_md_final)SHA1_Final,
 219         NULL
 220     };
 221     return &sha1;
 222 }
 223
 224 /**
 225  * The message digest MD5 - hcrypto
 226  *
 227  * @return the message digest type.
 228  *
 229  * @ingroup hcrypto_evp
 230  */
 231
 232 const EVP_MD *
 233 EVP_hcrypto_md5(void)
 234 {
 235     static const struct hc_evp_md md5 = {
 236         16,
 237         64,
 238         sizeof(MD5_CTX),
 239         (hc_evp_md_init)MD5_Init,
 240         (hc_evp_md_update)MD5_Update,
 241         (hc_evp_md_final)MD5_Final,
 242         NULL
 243     };
 244     return &md5;
 245 }
 246
 247 /**
 248  * The message digest MD4 - hcrypto
 249  *
 250  * @return the message digest type.
 251  *
 252  * @ingroup hcrypto_evp
 253  */
 254
 255 const EVP_MD *
 256 EVP_hcrypto_md4(void)
 257 {
 258     static const struct hc_evp_md md4 = {
 259         16,
 260         64,
 261         sizeof(MD4_CTX),
 262         (hc_evp_md_init)MD4_Init,
 263         (hc_evp_md_update)MD4_Update,
 264         (hc_evp_md_final)MD4_Final,
 265         NULL
 266     };
 267     return &md4;
 268 }
 269
 270 /**
 271  * The message digest MD2 - hcrypto
 272  *
 273  * @return the message digest type.
 274  *
 275  * @ingroup hcrypto_evp
 276  */
 277
 278 const EVP_MD *
 279 EVP_hcrypto_md2(void)
 280 {
 281     static const struct hc_evp_md md2 = {
 282         16,
 283         16,
 284         sizeof(MD2_CTX),
 285         (hc_evp_md_init)MD2_Init,
 286         (hc_evp_md_update)MD2_Update,
 287         (hc_evp_md_final)MD2_Final,
 288         NULL
 289     };
 290     return &md2;
 291 }
 292
 293 /*
 294  *
 295  */
 296
 297 static int
 298 des_cbc_init(EVP_CIPHER_CTX *ctx,
 299              const unsigned char * key,
 300              const unsigned char * iv,
 301              int encp)
 302 {
 303     DES_key_schedule *k = ctx->cipher_data;
 304     DES_cblock deskey;
 305     memcpy(&deskey, key, sizeof(deskey));
 306     DES_set_key_unchecked(&deskey, k);
 307     return 1;
 308 }
 309
 310 static int
 311 des_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
 312                   unsigned char *out,
 313                   const unsigned char *in,
 314                   unsigned int size)
 315 {
 316     DES_key_schedule *k = ctx->cipher_data;
 317     DES_cbc_encrypt(in, out, size,
 318                     k, (DES_cblock *)ctx->iv, ctx->encrypt);
 319     return 1;
 320 }
 321
 322 /**
 323  * The DES cipher type
 324  *
 325  * @return the DES-CBC EVP_CIPHER pointer.
 326  *
 327  * @ingroup hcrypto_evp
 328  */
 329
 330 const EVP_CIPHER *
 331 EVP_hcrypto_des_cbc(void)
 332 {
 333     static const EVP_CIPHER des_cbc = {
 334         0,
 335         8,
 336         8,
 337         8,
 338         EVP_CIPH_CBC_MODE,
 339         des_cbc_init,
 340         des_cbc_do_cipher,
 341         NULL,
 342         sizeof(DES_key_schedule),
 343         NULL,
 344         NULL,
 345         NULL,
 346         NULL
 347     };
 348     return &des_cbc;
 349 }
 350
 351 /*
 352  *
 353  */
 354
 355 struct des_ede3_cbc {
 356     DES_key_schedule ks[3];
 357 };
 358
 359 static int
 360 des_ede3_cbc_init(EVP_CIPHER_CTX *ctx,
 361                   const unsigned char * key,
 362                   const unsigned char * iv,
 363                   int encp)
 364 {
 365     struct des_ede3_cbc *k = ctx->cipher_data;
 366     DES_cblock deskey;
 367
 368     memcpy(&deskey, key, sizeof(deskey));
 369     DES_set_odd_parity(&deskey);
 370     DES_set_key_unchecked(&deskey, &k->ks[0]);
 371
 372     memcpy(&deskey, key + 8, sizeof(deskey));
 373     DES_set_odd_parity(&deskey);
 374     DES_set_key_unchecked(&deskey, &k->ks[1]);
 375
 376     memcpy(&deskey, key + 16, sizeof(deskey));
 377     DES_set_odd_parity(&deskey);
 378     DES_set_key_unchecked(&deskey, &k->ks[2]);
 379
 380     return 1;
 381 }
 382
 383 static int
 384 des_ede3_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
 385                        unsigned char *out,
 386                        const unsigned char *in,
 387                        unsigned int size)
 388 {
 389     struct des_ede3_cbc *k = ctx->cipher_data;
 390     DES_ede3_cbc_encrypt(in, out, size,
 391                          &k->ks[0], &k->ks[1], &k->ks[2],
 392                          (DES_cblock *)ctx->iv, ctx->encrypt);
 393     return 1;
 394 }
 395
 396 /**
 397  * The tripple DES cipher type - hcrypto
 398  *
 399  * @return the DES-EDE3-CBC EVP_CIPHER pointer.
 400  *
 401  * @ingroup hcrypto_evp
 402  */
 403
 404 const EVP_CIPHER *
 405 EVP_hcrypto_des_ede3_cbc(void)
 406 {
 407     static const EVP_CIPHER des_ede3_cbc = {
 408         0,
 409         8,
 410         24,
 411         8,
 412         EVP_CIPH_CBC_MODE,
 413         des_ede3_cbc_init,
 414         des_ede3_cbc_do_cipher,
 415         NULL,
 416         sizeof(struct des_ede3_cbc),
 417         NULL,
 418         NULL,
 419         NULL,
 420         NULL
 421     };
 422     return &des_ede3_cbc;
 423 }
 424
 425 /*
 426  *
 427  */
 428
 429 struct rc2_cbc {
 430     unsigned int maximum_effective_key;
 431     RC2_KEY key;
 432 };
 433
 434 static int
 435 rc2_init(EVP_CIPHER_CTX *ctx,
 436          const unsigned char * key,
 437          const unsigned char * iv,
 438          int encp)
 439 {
 440     struct rc2_cbc *k = ctx->cipher_data;
 441     k->maximum_effective_key = EVP_CIPHER_CTX_key_length(ctx) * 8;
 442     RC2_set_key(&k->key,
 443                 EVP_CIPHER_CTX_key_length(ctx),
 444                 key,
 445                 k->maximum_effective_key);
 446     return 1;
 447 }
 448
 449 static int
 450 rc2_do_cipher(EVP_CIPHER_CTX *ctx,
 451               unsigned char *out,
 452               const unsigned char *in,
 453               unsigned int size)
 454 {
 455     struct rc2_cbc *k = ctx->cipher_data;
 456     RC2_cbc_encrypt(in, out, size, &k->key, ctx->iv, ctx->encrypt);
 457     return 1;
 458 }
 459
 460 /**
 461  * The RC2 cipher type - hcrypto
 462  *
 463  * @return the RC2 EVP_CIPHER pointer.
 464  *
 465  * @ingroup hcrypto_evp
 466  */
 467
 468 const EVP_CIPHER *
 469 EVP_hcrypto_rc2_cbc(void)
 470 {
 471     static const EVP_CIPHER rc2_cbc = {
 472         0,
 473         RC2_BLOCK_SIZE,
 474         RC2_KEY_LENGTH,
 475         RC2_BLOCK_SIZE,
 476         EVP_CIPH_CBC_MODE|EVP_CIPH_VARIABLE_LENGTH,
 477         rc2_init,
 478         rc2_do_cipher,
 479         NULL,
 480         sizeof(struct rc2_cbc),
 481         NULL,
 482         NULL,
 483         NULL,
 484         NULL
 485     };
 486     return &rc2_cbc;
 487 }
 488
 489 /**
 490  * The RC2-40 cipher type
 491  *
 492  * @return the RC2-40 EVP_CIPHER pointer.
 493  *
 494  * @ingroup hcrypto_evp
 495  */
 496
 497 const EVP_CIPHER *
 498 EVP_hcrypto_rc2_40_cbc(void)
 499 {
 500     static const EVP_CIPHER rc2_40_cbc = {
 501         0,
 502         RC2_BLOCK_SIZE,
 503         5,
 504         RC2_BLOCK_SIZE,
 505         EVP_CIPH_CBC_MODE,
 506         rc2_init,
 507         rc2_do_cipher,
 508         NULL,
 509         sizeof(struct rc2_cbc),
 510         NULL,
 511         NULL,
 512         NULL,
 513         NULL
 514     };
 515     return &rc2_40_cbc;
 516 }
 517
 518 /**
 519  * The RC2-64 cipher type
 520  *
 521  * @return the RC2-64 EVP_CIPHER pointer.
 522  *
 523  * @ingroup hcrypto_evp
 524  */
 525
 526 const EVP_CIPHER *
 527 EVP_hcrypto_rc2_64_cbc(void)
 528 {
 529     static const EVP_CIPHER rc2_64_cbc = {
 530         0,
 531         RC2_BLOCK_SIZE,
 532         8,
 533         RC2_BLOCK_SIZE,
 534         EVP_CIPH_CBC_MODE,
 535         rc2_init,
 536         rc2_do_cipher,
 537         NULL,
 538         sizeof(struct rc2_cbc),
 539         NULL,
 540         NULL,
 541         NULL,
 542         NULL
 543     };
 544     return &rc2_64_cbc;
 545 }
 546
 547 static int
 548 camellia_init(EVP_CIPHER_CTX *ctx,
 549          const unsigned char * key,
 550          const unsigned char * iv,
 551          int encp)
 552 {
 553     CAMELLIA_KEY *k = ctx->cipher_data;
 554     k->bits = ctx->cipher->key_len * 8;
 555     CAMELLIA_set_key(key, ctx->cipher->key_len * 8, k);
 556     return 1;
 557 }
 558
 559 static int
 560 camellia_do_cipher(EVP_CIPHER_CTX *ctx,
 561               unsigned char *out,
 562               const unsigned char *in,
 563               unsigned int size)
 564 {
 565     CAMELLIA_KEY *k = ctx->cipher_data;
 566     CAMELLIA_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
 567     return 1;
 568 }
 569
 570 /**
 571  * The Camellia-128 cipher type - hcrypto
 572  *
 573  * @return the Camellia-128 EVP_CIPHER pointer.
 574  *
 575  * @ingroup hcrypto_evp
 576  */
 577
 578 const EVP_CIPHER *
 579 EVP_hcrypto_camellia_128_cbc(void)
 580 {
 581     static const EVP_CIPHER cipher = {
 582         0,
 583         16,
 584         16,
 585         16,
 586         EVP_CIPH_CBC_MODE,
 587         camellia_init,
 588         camellia_do_cipher,
 589         NULL,
 590         sizeof(CAMELLIA_KEY),
 591         NULL,
 592         NULL,
 593         NULL,
 594         NULL
 595     };
 596     return &cipher;
 597 }
 598
 599 /**
 600  * The Camellia-198 cipher type - hcrypto
 601  *
 602  * @return the Camellia-198 EVP_CIPHER pointer.
 603  *
 604  * @ingroup hcrypto_evp
 605  */
 606
 607 const EVP_CIPHER *
 608 EVP_hcrypto_camellia_192_cbc(void)
 609 {
 610     static const EVP_CIPHER cipher = {
 611         0,
 612         16,
 613         24,
 614         16,
 615         EVP_CIPH_CBC_MODE,
 616         camellia_init,
 617         camellia_do_cipher,
 618         NULL,
 619         sizeof(CAMELLIA_KEY),
 620         NULL,
 621         NULL,
 622         NULL,
 623         NULL
 624     };
 625     return &cipher;
 626 }
 627
 628 /**
 629  * The Camellia-256 cipher type - hcrypto
 630  *
 631  * @return the Camellia-256 EVP_CIPHER pointer.
 632  *
 633  * @ingroup hcrypto_evp
 634  */
 635
 636 const EVP_CIPHER *
 637 EVP_hcrypto_camellia_256_cbc(void)
 638 {
 639     static const EVP_CIPHER cipher = {
 640         0,
 641         16,
 642         32,
 643         16,
 644         EVP_CIPH_CBC_MODE,
 645         camellia_init,
 646         camellia_do_cipher,
 647         NULL,
 648         sizeof(CAMELLIA_KEY),
 649         NULL,
 650         NULL,
 651         NULL,
 652         NULL
 653     };
 654     return &cipher;
 655 }
 656
 657 static int
 658 rc4_init(EVP_CIPHER_CTX *ctx,
 659          const unsigned char *key,
 660          const unsigned char *iv,
 661          int enc)
 662 {
 663     RC4_KEY *k = ctx->cipher_data;
 664     RC4_set_key(k, ctx->key_len, key);
 665     return 1;
 666 }
 667
 668 static int
 669 rc4_do_cipher(EVP_CIPHER_CTX *ctx,
 670               unsigned char *out,
 671               const unsigned char *in,
 672               unsigned int size)
 673 {
 674     RC4_KEY *k = ctx->cipher_data;
 675     RC4(k, size, in, out);
 676     return 1;
 677 }
 678
 679 const EVP_CIPHER *
 680 EVP_hcrypto_rc4(void)
 681 {
 682     static const EVP_CIPHER rc4 = {
 683         0,
 684         1,
 685         16,
 686         0,
 687         EVP_CIPH_STREAM_CIPHER|EVP_CIPH_VARIABLE_LENGTH,
 688         rc4_init,
 689         rc4_do_cipher,
 690         NULL,
 691         sizeof(RC4_KEY),
 692         NULL,
 693         NULL,
 694         NULL,
 695         NULL
 696     };
 697     return &rc4;
 698 }
 699
 700
 701 const EVP_CIPHER *
 702 EVP_hcrypto_rc4_40(void)
 703 {
 704     static const EVP_CIPHER rc4_40 = {
 705         0,
 706         1,
 707         5,
 708         0,
 709         EVP_CIPH_STREAM_CIPHER|EVP_CIPH_VARIABLE_LENGTH,
 710         rc4_init,
 711         rc4_do_cipher,
 712         NULL,
 713         sizeof(RC4_KEY),
 714         NULL,
 715         NULL,
 716         NULL,
 717         NULL
 718     };
 719     return &rc4_40;
 720 }