lib/hcrypto/evp.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 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  37
  38 #define HC_DEPRECATED
  39 #define HC_DEPRECATED_CRYPTO
  40
  41 #include <sys/types.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <assert.h>
  46
  47 #include <evp.h>
  48 #include <evp-hcrypto.h>
  49 #include <evp-cc.h>
  50
  51 #include <krb5-types.h>
  52
  53 #ifndef HCRYPTO_DEF_PROVIDER
  54 #define HCRYPTO_DEF_PROVIDER hcrypto
  55 #endif
  56
  57 #define HC_CONCAT4(x,y,z,aa)    x ## y ## z ## aa
  58
  59
  60 #define EVP_DEF_OP(_prov,_op) HC_CONCAT4(EVP_,_prov,_,_op)()
  61
  62 /**
  63  * @page page_evp EVP - generic crypto interface
  64  *
  65  * See the library functions here: @ref hcrypto_evp
  66  *
  67  * @section evp_cipher EVP Cipher
  68  *
  69  * The use of EVP_CipherInit_ex() and EVP_Cipher() is pretty easy to
  70  * understand forward, then EVP_CipherUpdate() and
  71  * EVP_CipherFinal_ex() really needs an example to explain @ref
  72  * example_evp_cipher.c .
  73  *
  74  * @example example_evp_cipher.c
  75  *
  76  * This is an example how to use EVP_CipherInit_ex(),
  77  * EVP_CipherUpdate() and EVP_CipherFinal_ex().
  78  */
  79
  80 struct hc_EVP_MD_CTX {
  81     const EVP_MD *md;
  82     ENGINE *engine;
  83     void *ptr;
  84 };
  85
  86
  87 /**
  88  * Return the output size of the message digest function.
  89  *
  90  * @param md the evp message
  91  *
  92  * @return size output size of the message digest function.
  93  *
  94  * @ingroup hcrypto_evp
  95  */
  96
  97 size_t
  98 EVP_MD_size(const EVP_MD *md)
  99 {
 100     return md->hash_size;
 101 }
 102
 103 /**
 104  * Return the blocksize of the message digest function.
 105  *
 106  * @param md the evp message
 107  *
 108  * @return size size of the message digest block size
 109  *
 110  * @ingroup hcrypto_evp
 111  */
 112
 113 size_t
 114 EVP_MD_block_size(const EVP_MD *md)
 115 {
 116     return md->block_size;
 117 }
 118
 119 /**
 120  * Allocate a messsage digest context object. Free with
 121  * EVP_MD_CTX_destroy().
 122  *
 123  * @return a newly allocated message digest context object.
 124  *
 125  * @ingroup hcrypto_evp
 126  */
 127
 128 EVP_MD_CTX *
 129 EVP_MD_CTX_create(void)
 130 {
 131     return calloc(1, sizeof(EVP_MD_CTX));
 132 }
 133
 134 /**
 135  * Initiate a messsage digest context object. Deallocate with
 136  * EVP_MD_CTX_cleanup(). Please use EVP_MD_CTX_create() instead.
 137  *
 138  * @param ctx variable to initiate.
 139  *
 140  * @ingroup hcrypto_evp
 141  */
 142
 143 void
 144 EVP_MD_CTX_init(EVP_MD_CTX *ctx) HC_DEPRECATED
 145 {
 146     memset(ctx, 0, sizeof(*ctx));
 147 }
 148
 149 /**
 150  * Free a messsage digest context object.
 151  *
 152  * @param ctx context to free.
 153  *
 154  * @ingroup hcrypto_evp
 155  */
 156
 157 void
 158 EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
 159 {
 160     EVP_MD_CTX_cleanup(ctx);
 161     free(ctx);
 162 }
 163
 164 /**
 165  * Free the resources used by the EVP_MD context.
 166  *
 167  * @param ctx the context to free the resources from.
 168  *
 169  * @return 1 on success.
 170  *
 171  * @ingroup hcrypto_evp
 172  */
 173
 174 int
 175 EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx) HC_DEPRECATED
 176 {
 177     if (ctx->md && ctx->md->cleanup)
 178         (ctx->md->cleanup)(ctx);
 179     else if (ctx->md)
 180         memset(ctx->ptr, 0, ctx->md->ctx_size);
 181     ctx->md = NULL;
 182     ctx->engine = NULL;
 183     free(ctx->ptr);
 184     memset(ctx, 0, sizeof(*ctx));
 185     return 1;
 186 }
 187
 188 /**
 189  * Get the EVP_MD use for a specified context.
 190  *
 191  * @param ctx the EVP_MD context to get the EVP_MD for.
 192  *
 193  * @return the EVP_MD used for the context.
 194  *
 195  * @ingroup hcrypto_evp
 196  */
 197
 198 const EVP_MD *
 199 EVP_MD_CTX_md(EVP_MD_CTX *ctx)
 200 {
 201     return ctx->md;
 202 }
 203
 204 /**
 205  * Return the output size of the message digest function.
 206  *
 207  * @param ctx the evp message digest context
 208  *
 209  * @return size output size of the message digest function.
 210  *
 211  * @ingroup hcrypto_evp
 212  */
 213
 214 size_t
 215 EVP_MD_CTX_size(EVP_MD_CTX *ctx)
 216 {
 217     return EVP_MD_size(ctx->md);
 218 }
 219
 220 /**
 221  * Return the blocksize of the message digest function.
 222  *
 223  * @param ctx the evp message digest context
 224  *
 225  * @return size size of the message digest block size
 226  *
 227  * @ingroup hcrypto_evp
 228  */
 229
 230 size_t
 231 EVP_MD_CTX_block_size(EVP_MD_CTX *ctx)
 232 {
 233     return EVP_MD_block_size(ctx->md);
 234 }
 235
 236 /**
 237  * Init a EVP_MD_CTX for use a specific message digest and engine.
 238  *
 239  * @param ctx the message digest context to init.
 240  * @param md the message digest to use.
 241  * @param engine the engine to use, NULL to use the default engine.
 242  *
 243  * @return 1 on success.
 244  *
 245  * @ingroup hcrypto_evp
 246  */
 247
 248 int
 249 EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *md, ENGINE *engine)
 250 {
 251     if (ctx->md != md || ctx->engine != engine) {
 252         EVP_MD_CTX_cleanup(ctx);
 253         ctx->md = md;
 254         ctx->engine = engine;
 255
 256         ctx->ptr = calloc(1, md->ctx_size);
 257         if (ctx->ptr == NULL)
 258             return 0;
 259     }
 260     (ctx->md->init)(ctx->ptr);
 261     return 1;
 262 }
 263
 264 /**
 265  * Update the digest with some data.
 266  *
 267  * @param ctx the context to update
 268  * @param data the data to update the context with
 269  * @param size length of data
 270  *
 271  * @return 1 on success.
 272  *
 273  * @ingroup hcrypto_evp
 274  */
 275
 276 int
 277 EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t size)
 278 {
 279     (ctx->md->update)(ctx->ptr, data, size);
 280     return 1;
 281 }
 282
 283 /**
 284  * Complete the message digest.
 285  *
 286  * @param ctx the context to complete.
 287  * @param hash the output of the message digest function. At least
 288  * EVP_MD_size().
 289  * @param size the output size of hash.
 290  *
 291  * @return 1 on success.
 292  *
 293  * @ingroup hcrypto_evp
 294  */
 295
 296 int
 297 EVP_DigestFinal_ex(EVP_MD_CTX *ctx, void *hash, unsigned int *size)
 298 {
 299     (ctx->md->final)(hash, ctx->ptr);
 300     if (size)
 301         *size = ctx->md->hash_size;
 302     return 1;
 303 }
 304
 305 /**
 306  * Do the whole EVP_MD_CTX_create(), EVP_DigestInit_ex(),
 307  * EVP_DigestUpdate(), EVP_DigestFinal_ex(), EVP_MD_CTX_destroy()
 308  * dance in one call.
 309  *
 310  * @param data the data to update the context with
 311  * @param dsize length of data
 312  * @param hash output data of at least EVP_MD_size() length.
 313  * @param hsize output length of hash.
 314  * @param md message digest to use
 315  * @param engine engine to use, NULL for default engine.
 316  *
 317  * @return 1 on success.
 318  *
 319  * @ingroup hcrypto_evp
 320  */
 321
 322 int
 323 EVP_Digest(const void *data, size_t dsize, void *hash, unsigned int *hsize,
 324            const EVP_MD *md, ENGINE *engine)
 325 {
 326     EVP_MD_CTX *ctx;
 327     int ret;
 328
 329     ctx = EVP_MD_CTX_create();
 330     if (ctx == NULL)
 331         return 0;
 332     ret = EVP_DigestInit_ex(ctx, md, engine);
 333     if (ret != 1) {
 334         EVP_MD_CTX_destroy(ctx);
 335         return ret;
 336     }
 337     ret = EVP_DigestUpdate(ctx, data, dsize);
 338     if (ret != 1) {
 339         EVP_MD_CTX_destroy(ctx);
 340         return ret;
 341     }
 342     ret = EVP_DigestFinal_ex(ctx, hash, hsize);
 343     EVP_MD_CTX_destroy(ctx);
 344     return ret;
 345 }
 346
 347 /**
 348  * The message digest SHA256
 349  *
 350  * @return the message digest type.
 351  *
 352  * @ingroup hcrypto_evp
 353  */
 354
 355 const EVP_MD *
 356 EVP_sha256(void)
 357 {
 358     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, sha256);
 359 }
 360
 361 /**
 362  * The message digest SHA1
 363  *
 364  * @return the message digest type.
 365  *
 366  * @ingroup hcrypto_evp
 367  */
 368
 369 const EVP_MD *
 370 EVP_sha1(void)
 371 {
 372     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, sha1);
 373 }
 374
 375 /**
 376  * The message digest SHA1
 377  *
 378  * @return the message digest type.
 379  *
 380  * @ingroup hcrypto_evp
 381  */
 382
 383 const EVP_MD *
 384 EVP_sha(void) HC_DEPRECATED
 385
 386 {
 387     return EVP_sha1();
 388 }
 389
 390 /**
 391  * The message digest MD5
 392  *
 393  * @return the message digest type.
 394  *
 395  * @ingroup hcrypto_evp
 396  */
 397
 398 const EVP_MD *
 399 EVP_md5(void) HC_DEPRECATED_CRYPTO
 400 {
 401     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, md5);
 402 }
 403
 404 /**
 405  * The message digest MD4
 406  *
 407  * @return the message digest type.
 408  *
 409  * @ingroup hcrypto_evp
 410  */
 411
 412 const EVP_MD *
 413 EVP_md4(void) HC_DEPRECATED_CRYPTO
 414 {
 415     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, md4);
 416 }
 417
 418 /**
 419  * The message digest MD2
 420  *
 421  * @return the message digest type.
 422  *
 423  * @ingroup hcrypto_evp
 424  */
 425
 426 const EVP_MD *
 427 EVP_md2(void) HC_DEPRECATED_CRYPTO
 428 {
 429     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, md2);
 430 }
 431
 432 /*
 433  *
 434  */
 435
 436 static void
 437 null_Init (void *m)
 438 {
 439 }
 440 static void
 441 null_Update (void *m, const void * data, size_t size)
 442 {
 443 }
 444 static void
 445 null_Final(void *res, void *m)
 446 {
 447 }
 448
 449 /**
 450  * The null message digest
 451  *
 452  * @return the message digest type.
 453  *
 454  * @ingroup hcrypto_evp
 455  */
 456
 457 const EVP_MD *
 458 EVP_md_null(void)
 459 {
 460     static const struct hc_evp_md null = {
 461         0,
 462         0,
 463         0,
 464         (hc_evp_md_init)null_Init,
 465         (hc_evp_md_update)null_Update,
 466         (hc_evp_md_final)null_Final,
 467         NULL
 468     };
 469     return &null;
 470 }
 471
 472 /**
 473  * Return the block size of the cipher.
 474  *
 475  * @param c cipher to get the block size from.
 476  *
 477  * @return the block size of the cipher.
 478  *
 479  * @ingroup hcrypto_evp
 480  */
 481
 482 size_t
 483 EVP_CIPHER_block_size(const EVP_CIPHER *c)
 484 {
 485     return c->block_size;
 486 }
 487
 488 /**
 489  * Return the key size of the cipher.
 490  *
 491  * @param c cipher to get the key size from.
 492  *
 493  * @return the key size of the cipher.
 494  *
 495  * @ingroup hcrypto_evp
 496  */
 497
 498 size_t
 499 EVP_CIPHER_key_length(const EVP_CIPHER *c)
 500 {
 501     return c->key_len;
 502 }
 503
 504 /**
 505  * Return the IV size of the cipher.
 506  *
 507  * @param c cipher to get the IV size from.
 508  *
 509  * @return the IV size of the cipher.
 510  *
 511  * @ingroup hcrypto_evp
 512  */
 513
 514 size_t
 515 EVP_CIPHER_iv_length(const EVP_CIPHER *c)
 516 {
 517     return c->iv_len;
 518 }
 519
 520 /**
 521  * Initiate a EVP_CIPHER_CTX context. Clean up with
 522  * EVP_CIPHER_CTX_cleanup().
 523  *
 524  * @param c the cipher initiate.
 525  *
 526  * @ingroup hcrypto_evp
 527  */
 528
 529 void
 530 EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *c)
 531 {
 532     memset(c, 0, sizeof(*c));
 533 }
 534
 535 /**
 536  * Clean up the EVP_CIPHER_CTX context.
 537  *
 538  * @param c the cipher to clean up.
 539  *
 540  * @return 1 on success.
 541  *
 542  * @ingroup hcrypto_evp
 543  */
 544
 545 int
 546 EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
 547 {
 548     if (c->cipher && c->cipher->cleanup)
 549         c->cipher->cleanup(c);
 550     if (c->cipher_data) {
 551         memset(c->cipher_data, 0, c->cipher->ctx_size);
 552         free(c->cipher_data);
 553         c->cipher_data = NULL;
 554     }
 555     return 1;
 556 }
 557
 558 /**
 559  * If the cipher type supports it, change the key length
 560  *
 561  * @param c the cipher context to change the key length for
 562  * @param length new key length
 563  *
 564  * @return 1 on success.
 565  *
 566  * @ingroup hcrypto_evp
 567  */
 568
 569 int
 570 EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int length)
 571 {
 572     if ((c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH) && length > 0) {
 573         c->key_len = length;
 574         return 1;
 575     }
 576     return 0;
 577 }
 578
 579 #if 0
 580 int
 581 EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad)
 582 {
 583     return 0;
 584 }
 585 #endif
 586
 587 /**
 588  * Return the EVP_CIPHER for a EVP_CIPHER_CTX context.
 589  *
 590  * @param ctx the context to get the cipher type from.
 591  *
 592  * @return the EVP_CIPHER pointer.
 593  *
 594  * @ingroup hcrypto_evp
 595  */
 596
 597 const EVP_CIPHER *
 598 EVP_CIPHER_CTX_cipher(EVP_CIPHER_CTX *ctx)
 599 {
 600     return ctx->cipher;
 601 }
 602
 603 /**
 604  * Return the block size of the cipher context.
 605  *
 606  * @param ctx cipher context to get the block size from.
 607  *
 608  * @return the block size of the cipher context.
 609  *
 610  * @ingroup hcrypto_evp
 611  */
 612
 613 size_t
 614 EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
 615 {
 616     return EVP_CIPHER_block_size(ctx->cipher);
 617 }
 618
 619 /**
 620  * Return the key size of the cipher context.
 621  *
 622  * @param ctx cipher context to get the key size from.
 623  *
 624  * @return the key size of the cipher context.
 625  *
 626  * @ingroup hcrypto_evp
 627  */
 628
 629 size_t
 630 EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
 631 {
 632     return EVP_CIPHER_key_length(ctx->cipher);
 633 }
 634
 635 /**
 636  * Return the IV size of the cipher context.
 637  *
 638  * @param ctx cipher context to get the IV size from.
 639  *
 640  * @return the IV size of the cipher context.
 641  *
 642  * @ingroup hcrypto_evp
 643  */
 644
 645 size_t
 646 EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
 647 {
 648     return EVP_CIPHER_iv_length(ctx->cipher);
 649 }
 650
 651 /**
 652  * Get the flags for an EVP_CIPHER_CTX context.
 653  *
 654  * @param ctx the EVP_CIPHER_CTX to get the flags from
 655  *
 656  * @return the flags for an EVP_CIPHER_CTX.
 657  *
 658  * @ingroup hcrypto_evp
 659  */
 660
 661 unsigned long
 662 EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
 663 {
 664     return ctx->cipher->flags;
 665 }
 666
 667 /**
 668  * Get the mode for an EVP_CIPHER_CTX context.
 669  *
 670  * @param ctx the EVP_CIPHER_CTX to get the mode from
 671  *
 672  * @return the mode for an EVP_CIPHER_CTX.
 673  *
 674  * @ingroup hcrypto_evp
 675  */
 676
 677 int
 678 EVP_CIPHER_CTX_mode(const EVP_CIPHER_CTX *ctx)
 679 {
 680     return EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_MODE;
 681 }
 682
 683 /**
 684  * Get the app data for an EVP_CIPHER_CTX context.
 685  *
 686  * @param ctx the EVP_CIPHER_CTX to get the app data from
 687  *
 688  * @return the app data for an EVP_CIPHER_CTX.
 689  *
 690  * @ingroup hcrypto_evp
 691  */
 692
 693 void *
 694 EVP_CIPHER_CTX_get_app_data(EVP_CIPHER_CTX *ctx)
 695 {
 696     return ctx->app_data;
 697 }
 698
 699 /**
 700  * Set the app data for an EVP_CIPHER_CTX context.
 701  *
 702  * @param ctx the EVP_CIPHER_CTX to set the app data for
 703  * @param data the app data to set for an EVP_CIPHER_CTX.
 704  *
 705  * @ingroup hcrypto_evp
 706  */
 707
 708 void
 709 EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
 710 {
 711     ctx->app_data = data;
 712 }
 713
 714 /**
 715  * Initiate the EVP_CIPHER_CTX context to encrypt or decrypt data.
 716  * Clean up with EVP_CIPHER_CTX_cleanup().
 717  *
 718  * @param ctx context to initiate
 719  * @param c cipher to use.
 720  * @param engine crypto engine to use, NULL to select default.
 721  * @param key the crypto key to use, NULL will use the previous value.
 722  * @param iv the IV to use, NULL will use the previous value.
 723  * @param encp non zero will encrypt, -1 use the previous value.
 724  *
 725  * @return 1 on success.
 726  *
 727  * @ingroup hcrypto_evp
 728  */
 729
 730 int
 731 EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *c, ENGINE *engine,
 732                   const void *key, const void *iv, int encp)
 733 {
 734     ctx->buf_len = 0;
 735
 736     if (encp == -1)
 737         encp = ctx->encrypt;
 738     else
 739         ctx->encrypt = (encp ? 1 : 0);
 740
 741     if (c && (c != ctx->cipher)) {
 742         EVP_CIPHER_CTX_cleanup(ctx);
 743         ctx->cipher = c;
 744         ctx->key_len = c->key_len;
 745
 746         ctx->cipher_data = calloc(1, c->ctx_size);
 747         if (ctx->cipher_data == NULL && c->ctx_size != 0)
 748             return 0;
 749
 750         /* assume block size is a multiple of 2 */
 751         ctx->block_mask = EVP_CIPHER_block_size(c) - 1;
 752
 753     } else if (ctx->cipher == NULL) {
 754         /* reuse of cipher, but not any cipher ever set! */
 755         return 0;
 756     }
 757
 758     switch (EVP_CIPHER_CTX_mode(ctx)) {
 759     case EVP_CIPH_CBC_MODE:
 760
 761         assert(EVP_CIPHER_CTX_iv_length(ctx) <= sizeof(ctx->iv));
 762
 763         if (iv)
 764             memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
 765         memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
 766         break;
 767
 768     case EVP_CIPH_STREAM_CIPHER:
 769         break;
 770
 771     default:
 772         return 0;
 773     }
 774
 775     if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT))
 776         ctx->cipher->init(ctx, key, iv, encp);
 777
 778     return 1;
 779 }
 780
 781 /**
 782  * Encipher/decipher partial data
 783  *
 784  * @param ctx the cipher context.
 785  * @param out output data from the operation.
 786  * @param outlen output length
 787  * @param in input data to the operation.
 788  * @param inlen length of data.
 789  *
 790  * The output buffer length should at least be EVP_CIPHER_block_size()
 791  * byte longer then the input length.
 792  *
 793  * See @ref evp_cipher for an example how to use this function.
 794  *
 795  * @return 1 on success.
 796  *
 797  * @ingroup hcrypto_evp
 798  */
 799
 800 int
 801 EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, void *out, int *outlen,
 802                  void *in, size_t inlen)
 803 {
 804     int ret, left, blocksize;
 805
 806     *outlen = 0;
 807
 808     /**
 809      * If there in no spare bytes in the left from last Update and the
 810      * input length is on the block boundery, the EVP_CipherUpdate()
 811      * function can take a shortcut (and preformance gain) and
 812      * directly encrypt the data, otherwise we hav to fix it up and
 813      * store extra it the EVP_CIPHER_CTX.
 814      */
 815     if (ctx->buf_len == 0 && (inlen & ctx->block_mask) == 0) {
 816         ret = (*ctx->cipher->do_cipher)(ctx, out, in, inlen);
 817         if (ret == 1)
 818             *outlen = inlen;
 819         else
 820             *outlen = 0;
 821         return ret;
 822     }
 823
 824
 825     blocksize = EVP_CIPHER_CTX_block_size(ctx);
 826     left = blocksize - ctx->buf_len;
 827     assert(left > 0);
 828
 829     if (ctx->buf_len) {
 830
 831         /* if total buffer is smaller then input, store locally */
 832         if (inlen < left) {
 833             memcpy(ctx->buf + ctx->buf_len, in, inlen);
 834             ctx->buf_len += inlen;
 835             return 1;
 836         }
 837
 838         /* fill in local buffer and encrypt */
 839         memcpy(ctx->buf + ctx->buf_len, in, left);
 840         ret = (*ctx->cipher->do_cipher)(ctx, out, ctx->buf, blocksize);
 841         memset(ctx->buf, 0, blocksize);
 842         if (ret != 1)
 843             return ret;
 844
 845         *outlen += blocksize;
 846         inlen -= left;
 847         in = ((unsigned char *)in) + left;
 848         out = ((unsigned char *)out) + blocksize;
 849         ctx->buf_len = 0;
 850     }
 851
 852     if (inlen) {
 853         ctx->buf_len = (inlen & ctx->block_mask);
 854         inlen &= ~ctx->block_mask;
 855
 856         ret = (*ctx->cipher->do_cipher)(ctx, out, in, inlen);
 857         if (ret != 1)
 858             return ret;
 859
 860         *outlen += inlen;
 861
 862         in = ((unsigned char *)in) + inlen;
 863         memcpy(ctx->buf, in, ctx->buf_len);
 864     }
 865
 866     return 1;
 867 }
 868
 869 /**
 870  * Encipher/decipher final data
 871  *
 872  * @param ctx the cipher context.
 873  * @param out output data from the operation.
 874  * @param outlen output length
 875  *
 876  * The input length needs to be at least EVP_CIPHER_block_size() bytes
 877  * long.
 878  *
 879  * See @ref evp_cipher for an example how to use this function.
 880  *
 881  * @return 1 on success.
 882  *
 883  * @ingroup hcrypto_evp
 884  */
 885
 886 int
 887 EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, void *out, int *outlen)
 888 {
 889     *outlen = 0;
 890
 891     if (ctx->buf_len) {
 892         int ret, left, blocksize;
 893
 894         blocksize = EVP_CIPHER_CTX_block_size(ctx);
 895
 896         left = blocksize - ctx->buf_len;
 897         assert(left > 0);
 898
 899         /* zero fill local buffer */
 900         memset(ctx->buf + ctx->buf_len, 0, left);
 901         ret = (*ctx->cipher->do_cipher)(ctx, out, ctx->buf, blocksize);
 902         memset(ctx->buf, 0, blocksize);
 903         if (ret != 1)
 904             return ret;
 905
 906         *outlen += blocksize;
 907     }
 908
 909     return 1;
 910 }
 911
 912 /**
 913  * Encipher/decipher data
 914  *
 915  * @param ctx the cipher context.
 916  * @param out out data from the operation.
 917  * @param in in data to the operation.
 918  * @param size length of data.
 919  *
 920  * @return 1 on success.
 921  */
 922
 923 int
 924 EVP_Cipher(EVP_CIPHER_CTX *ctx, void *out, const void *in,size_t size)
 925 {
 926     return ctx->cipher->do_cipher(ctx, out, in, size);
 927 }
 928
 929 /*
 930  *
 931  */
 932
 933 static int
 934 enc_null_init(EVP_CIPHER_CTX *ctx,
 935                   const unsigned char * key,
 936                   const unsigned char * iv,
 937                   int encp)
 938 {
 939     return 1;
 940 }
 941
 942 static int
 943 enc_null_do_cipher(EVP_CIPHER_CTX *ctx,
 944               unsigned char *out,
 945               const unsigned char *in,
 946               unsigned int size)
 947 {
 948     memmove(out, in, size);
 949     return 1;
 950 }
 951
 952 static int
 953 enc_null_cleanup(EVP_CIPHER_CTX *ctx)
 954 {
 955     return 1;
 956 }
 957
 958 /**
 959  * The NULL cipher type, does no encryption/decryption.
 960  *
 961  * @return the null EVP_CIPHER pointer.
 962  *
 963  * @ingroup hcrypto_evp
 964  */
 965
 966 const EVP_CIPHER *
 967 EVP_enc_null(void)
 968 {
 969     static const EVP_CIPHER enc_null = {
 970         0,
 971         0,
 972         0,
 973         0,
 974         EVP_CIPH_CBC_MODE,
 975         enc_null_init,
 976         enc_null_do_cipher,
 977         enc_null_cleanup,
 978         0,
 979         NULL,
 980         NULL,
 981         NULL,
 982         NULL
 983     };
 984     return &enc_null;
 985 }
 986
 987 /**
 988  * The RC2 cipher type
 989  *
 990  * @return the RC2 EVP_CIPHER pointer.
 991  *
 992  * @ingroup hcrypto_evp
 993  */
 994
 995 const EVP_CIPHER *
 996 EVP_rc2_cbc(void)
 997 {
 998     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, rc2_cbc);
 999 }
1000
1001 /**
1002  * The RC2 cipher type
1003  *
1004  * @return the RC2 EVP_CIPHER pointer.
1005  *
1006  * @ingroup hcrypto_evp
1007  */
1008
1009 const EVP_CIPHER *
1010 EVP_rc2_40_cbc(void)
1011 {
1012     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, rc2_40_cbc);
1013 }
1014
1015 /**
1016  * The RC2 cipher type
1017  *
1018  * @return the RC2 EVP_CIPHER pointer.
1019  *
1020  * @ingroup hcrypto_evp
1021  */
1022
1023 const EVP_CIPHER *
1024 EVP_rc2_64_cbc(void)
1025 {
1026     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, rc2_64_cbc);
1027 }
1028
1029 /**
1030  * The RC4 cipher type
1031  *
1032  * @return the RC4 EVP_CIPHER pointer.
1033  *
1034  * @ingroup hcrypto_evp
1035  */
1036
1037 const EVP_CIPHER *
1038 EVP_rc4(void)
1039 {
1040     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, rc4);
1041 }
1042
1043 /**
1044  * The RC4-40 cipher type
1045  *
1046  * @return the RC4-40 EVP_CIPHER pointer.
1047  *
1048  * @ingroup hcrypto_evp
1049  */
1050
1051 const EVP_CIPHER *
1052 EVP_rc4_40(void)
1053 {
1054     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, rc4_40);
1055 }
1056
1057 /**
1058  * The DES cipher type
1059  *
1060  * @return the DES-CBC EVP_CIPHER pointer.
1061  *
1062  * @ingroup hcrypto_evp
1063  */
1064
1065 const EVP_CIPHER *
1066 EVP_des_cbc(void)
1067 {
1068     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, des_cbc);
1069 }
1070
1071 /**
1072  * The tripple DES cipher type
1073  *
1074  * @return the DES-EDE3-CBC EVP_CIPHER pointer.
1075  *
1076  * @ingroup hcrypto_evp
1077  */
1078
1079 const EVP_CIPHER *
1080 EVP_des_ede3_cbc(void)
1081 {
1082     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, des_ede3_cbc);
1083 }
1084
1085 /**
1086  * The AES-128 cipher type
1087  *
1088  * @return the AES-128 EVP_CIPHER pointer.
1089  *
1090  * @ingroup hcrypto_evp
1091  */
1092
1093 const EVP_CIPHER *
1094 EVP_aes_128_cbc(void)
1095 {
1096     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, aes_128_cbc);
1097 }
1098
1099 /**
1100  * The AES-192 cipher type
1101  *
1102  * @return the AES-192 EVP_CIPHER pointer.
1103  *
1104  * @ingroup hcrypto_evp
1105  */
1106
1107 const EVP_CIPHER *
1108 EVP_aes_192_cbc(void)
1109 {
1110     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, aes_192_cbc);
1111 }
1112
1113 /**
1114  * The AES-256 cipher type
1115  *
1116  * @return the AES-256 EVP_CIPHER pointer.
1117  *
1118  * @ingroup hcrypto_evp
1119  */
1120
1121 const EVP_CIPHER *
1122 EVP_aes_256_cbc(void)
1123 {
1124     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, aes_256_cbc);
1125 }
1126
1127 /**
1128  * The Camellia-128 cipher type
1129  *
1130  * @return the Camellia-128 EVP_CIPHER pointer.
1131  *
1132  * @ingroup hcrypto_evp
1133  */
1134
1135 const EVP_CIPHER *
1136 EVP_camellia_128_cbc(void)
1137 {
1138     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, camellia_128_cbc);
1139 }
1140
1141 /**
1142  * The Camellia-198 cipher type
1143  *
1144  * @return the Camellia-198 EVP_CIPHER pointer.
1145  *
1146  * @ingroup hcrypto_evp
1147  */
1148
1149 const EVP_CIPHER *
1150 EVP_camellia_192_cbc(void)
1151 {
1152     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, camellia_192_cbc);
1153 }
1154
1155 /**
1156  * The Camellia-256 cipher type
1157  *
1158  * @return the Camellia-256 EVP_CIPHER pointer.
1159  *
1160  * @ingroup hcrypto_evp
1161  */
1162
1163 const EVP_CIPHER *
1164 EVP_camellia_256_cbc(void)
1165 {
1166     return EVP_DEF_OP(HCRYPTO_DEF_PROVIDER, camellia_256_cbc);
1167 }
1168
1169 /*
1170  *
1171  */
1172
1173 static const struct cipher_name {
1174     const char *name;
1175     const EVP_CIPHER *(*func)(void);
1176 } cipher_name[] = {
1177     { "des-ede3-cbc", EVP_des_ede3_cbc },
1178     { "aes-128-cbc", EVP_aes_128_cbc },
1179     { "aes-192-cbc", EVP_aes_192_cbc },
1180     { "aes-256-cbc", EVP_aes_256_cbc },
1181     { "camellia-128-cbc", EVP_camellia_128_cbc },
1182     { "camellia-192-cbc", EVP_camellia_192_cbc },
1183     { "camellia-256-cbc", EVP_camellia_256_cbc }
1184 };
1185
1186 /**
1187  * Get the cipher type using their name.
1188  *
1189  * @param name the name of the cipher.
1190  *
1191  * @return the selected EVP_CIPHER pointer or NULL if not found.
1192  *
1193  * @ingroup hcrypto_evp
1194  */
1195
1196 const EVP_CIPHER *
1197 EVP_get_cipherbyname(const char *name)
1198 {
1199     int i;
1200     for (i = 0; i < sizeof(cipher_name)/sizeof(cipher_name[0]); i++) {
1201         if (strcasecmp(cipher_name[i].name, name) == 0)
1202             return (*cipher_name[i].func)();
1203     }
1204     return NULL;
1205 }
1206
1207
1208 /*
1209  *
1210  */
1211
1212 #ifndef min
1213 #define min(a,b) (((a)>(b))?(b):(a))
1214 #endif
1215
1216 /**
1217  * Provides a legancy string to key function, used in PEM files.
1218  *
1219  * New protocols should use new string to key functions like NIST
1220  * SP56-800A or PKCS#5 v2.0 (see PKCS5_PBKDF2_HMAC_SHA1()).
1221  *
1222  * @param type type of cipher to use
1223  * @param md message digest to use
1224  * @param salt salt salt string, should be an binary 8 byte buffer.
1225  * @param data the password/input key string.
1226  * @param datalen length of data parameter.
1227  * @param count iteration counter.
1228  * @param keydata output keydata, needs to of the size EVP_CIPHER_key_length().
1229  * @param ivdata output ivdata, needs to of the size EVP_CIPHER_block_size().
1230  *
1231  * @return the size of derived key.
1232  *
1233  * @ingroup hcrypto_evp
1234  */
1235
1236 int
1237 EVP_BytesToKey(const EVP_CIPHER *type,
1238                const EVP_MD *md,
1239                const void *salt,
1240                const void *data, size_t datalen,
1241                unsigned int count,
1242                void *keydata,
1243                void *ivdata)
1244 {
1245     int ivlen, keylen, first = 0;
1246     unsigned int mds = 0, i;
1247     unsigned char *key = keydata;
1248     unsigned char *iv = ivdata;
1249     unsigned char *buf;
1250     EVP_MD_CTX c;
1251
1252     keylen = EVP_CIPHER_key_length(type);
1253     ivlen = EVP_CIPHER_iv_length(type);
1254
1255     if (data == NULL)
1256         return keylen;
1257
1258     buf = malloc(EVP_MD_size(md));
1259     if (buf == NULL)
1260         return -1;
1261
1262     EVP_MD_CTX_init(&c);
1263
1264     first = 1;
1265     while (1) {
1266         EVP_DigestInit_ex(&c, md, NULL);
1267         if (!first)
1268             EVP_DigestUpdate(&c, buf, mds);
1269         first = 0;
1270         EVP_DigestUpdate(&c,data,datalen);
1271
1272 #define PKCS5_SALT_LEN 8
1273
1274         if (salt)
1275             EVP_DigestUpdate(&c, salt, PKCS5_SALT_LEN);
1276
1277         EVP_DigestFinal_ex(&c, buf, &mds);
1278         assert(mds == EVP_MD_size(md));
1279
1280         for (i = 1; i < count; i++) {
1281             EVP_DigestInit_ex(&c, md, NULL);
1282             EVP_DigestUpdate(&c, buf, mds);
1283             EVP_DigestFinal_ex(&c, buf, &mds);
1284             assert(mds == EVP_MD_size(md));
1285         }
1286
1287         i = 0;
1288         if (keylen) {
1289             size_t sz = min(keylen, mds);
1290             if (key) {
1291                 memcpy(key, buf, sz);
1292                 key += sz;
1293             }
1294             keylen -= sz;
1295             i += sz;
1296         }
1297         if (ivlen && mds > i) {
1298             size_t sz = min(ivlen, (mds - i));
1299             if (iv) {
1300                 memcpy(iv, &buf[i], sz);
1301                 iv += sz;
1302             }
1303             ivlen -= sz;
1304         }
1305         if (keylen == 0 && ivlen == 0)
1306             break;
1307     }
1308
1309     EVP_MD_CTX_cleanup(&c);
1310     free(buf);
1311
1312     return EVP_CIPHER_key_length(type);
1313 }
1314
1315 /**
1316  * Generate a random key for the specificed EVP_CIPHER.
1317  *
1318  * @param ctx EVP_CIPHER_CTX type to build the key for.
1319  * @param key return key, must be at least EVP_CIPHER_key_length() byte long.
1320  *
1321  * @return 1 for success, 0 for failure.
1322  *
1323  * @ingroup hcrypto_core
1324  */
1325
1326 int
1327 EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, void *key)
1328 {
1329     if (ctx->cipher->flags & EVP_CIPH_RAND_KEY)
1330         return EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_RAND_KEY, 0, key);
1331     if (RAND_bytes(key, ctx->key_len) != 1)
1332         return 0;
1333     return 1;
1334 }
1335
1336 /**
1337  * Perform a operation on a ctx
1338  *
1339  * @param ctx context to perform operation on.
1340  * @param type type of operation.
1341  * @param arg argument to operation.
1342  * @param data addition data to operation.
1343
1344  * @return 1 for success, 0 for failure.
1345  *
1346  * @ingroup hcrypto_core
1347  */
1348
1349 int
1350 EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *data)
1351 {
1352     if (ctx->cipher == NULL || ctx->cipher->ctrl == NULL)
1353         return 0;
1354     return (*ctx->cipher->ctrl)(ctx, type, arg, data);
1355 }
1356
1357 /**
1358  * Add all algorithms to the crypto core.
1359  *
1360  * @ingroup hcrypto_core
1361  */
1362
1363 void
1364 OpenSSL_add_all_algorithms(void)
1365 {
1366     return;
1367 }
1368
1369 /**
1370  * Add all algorithms to the crypto core using configuration file.
1371  *
1372  * @ingroup hcrypto_core
1373  */
1374
1375 void
1376 OpenSSL_add_all_algorithms_conf(void)
1377 {
1378     return;
1379 }
1380
1381 /**
1382  * Add all algorithms to the crypto core, but don't use the
1383  * configuration file.
1384  *
1385  * @ingroup hcrypto_core
1386  */
1387
1388 void
1389 OpenSSL_add_all_algorithms_noconf(void)
1390 {
1391     return;
1392 }