crypto/external/bsd/heimdal/dist/lib/hcrypto/evp-cc.c

   1 /*      $NetBSD: evp-cc.c,v 1.1.1.1 2011/04/13 18:14:49 elric Exp $     */
   2
   3 /*
   4  * Copyright (c) 2008 Kungliga Tekniska Högskolan
   5  * (Royal Institute of Technology, Stockholm, Sweden).
   6  * All rights reserved.
   7  *
   8  * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  *
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * 3. Neither the name of the Institute nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  */
  37
  38 /* CommonCrypto provider */
  39
  40 #ifdef __APPLE__
  41
  42 #include "config.h"
  43
  44 #include <sys/types.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <assert.h>
  49
  50 #ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
  51 #include <CommonCrypto/CommonDigest.h>
  52 #endif
  53 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
  54 #include <CommonCrypto/CommonCryptor.h>
  55 #endif
  56
  57 #include <evp.h>
  58 #include <evp-cc.h>
  59
  60 /*
  61  *
  62  */
  63
  64 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
  65
  66 struct cc_key {
  67     CCCryptorRef href;
  68 };
  69
  70 static int
  71 cc_do_cipher(EVP_CIPHER_CTX *ctx,
  72              unsigned char *out,
  73              const unsigned char *in,
  74              unsigned int size)
  75 {
  76     struct cc_key *cc = ctx->cipher_data;
  77     CCCryptorStatus ret;
  78     size_t moved;
  79
  80     memcpy(out, in, size);
  81
  82     ret = CCCryptorUpdate(cc->href, in, size, out, size, &moved);
  83     if (ret)
  84         return 0;
  85
  86     if (moved != size)
  87         return 0;
  88
  89     return 1;
  90 }
  91
  92 static int
  93 cc_do_cfb8_cipher(EVP_CIPHER_CTX *ctx,
  94                   unsigned char *out,
  95                   const unsigned char *in,
  96                   unsigned int size)
  97 {
  98     struct cc_key *cc = ctx->cipher_data;
  99     CCCryptorStatus ret;
 100     size_t moved;
 101     unsigned int i;
 102
 103     for (i = 0; i < size; i++) {
 104         unsigned char oiv[EVP_MAX_IV_LENGTH + 1];
 105
 106         assert(ctx->cipher->iv_len + 1 <= sizeof(oiv));
 107         memcpy(oiv, ctx->iv, ctx->cipher->iv_len);
 108
 109         ret = CCCryptorUpdate(cc->href, ctx->iv, ctx->cipher->iv_len,
 110                               ctx->iv, ctx->cipher->iv_len, &moved);
 111         if (ret)
 112             return 0;
 113
 114         if (moved != ctx->cipher->iv_len)
 115             return 0;
 116
 117         if (!ctx->encrypt)
 118             oiv[ctx->cipher->iv_len] = in[i];
 119         out[i] = in[i] ^ ctx->iv[0];
 120         if (ctx->encrypt)
 121             oiv[ctx->cipher->iv_len] = out[i];
 122
 123         memcpy(ctx->iv, &oiv[1], ctx->cipher->iv_len);
 124     }
 125
 126     return 1;
 127 }
 128
 129 static int
 130 cc_cleanup(EVP_CIPHER_CTX *ctx)
 131 {
 132     struct cc_key *cc = ctx->cipher_data;
 133     if (cc->href)
 134         CCCryptorRelease(cc->href);
 135     return 1;
 136 }
 137
 138 static int
 139 init_cc_key(int encp, CCAlgorithm alg, CCOptions opts, const void *key,
 140             size_t keylen, const void *iv, CCCryptorRef *ref)
 141 {
 142     CCOperation op = encp ? kCCEncrypt : kCCDecrypt;
 143     CCCryptorStatus ret;
 144
 145     if (*ref) {
 146         if (key == NULL && iv) {
 147             CCCryptorReset(*ref, iv);
 148             return 1;
 149         }
 150         CCCryptorRelease(*ref);
 151     }
 152
 153     ret = CCCryptorCreate(op, alg, opts, key, keylen, iv, ref);
 154     if (ret)
 155         return 0;
 156     return 1;
 157 }
 158
 159 static int
 160 cc_des_ede3_cbc_init(EVP_CIPHER_CTX *ctx,
 161                      const unsigned char * key,
 162                      const unsigned char * iv,
 163                      int encp)
 164 {
 165     struct cc_key *cc = ctx->cipher_data;
 166     return init_cc_key(encp, kCCAlgorithm3DES, 0, key, kCCKeySize3DES, iv, &cc->href);
 167 }
 168
 169 #endif /* HAVE_COMMONCRYPTO_COMMONCRYPTOR_H */
 170
 171 /**
 172  * The tripple DES cipher type (Apple CommonCrypto provider)
 173  *
 174  * @return the DES-EDE3-CBC EVP_CIPHER pointer.
 175  *
 176  * @ingroup hcrypto_evp
 177  */
 178
 179 const EVP_CIPHER *
 180 EVP_cc_des_ede3_cbc(void)
 181 {
 182 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 183     static const EVP_CIPHER des_ede3_cbc = {
 184         0,
 185         8,
 186         24,
 187         8,
 188         EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 189         cc_des_ede3_cbc_init,
 190         cc_do_cipher,
 191         cc_cleanup,
 192         sizeof(struct cc_key),
 193         NULL,
 194         NULL,
 195         NULL,
 196         NULL
 197     };
 198     return &des_ede3_cbc;
 199 #else
 200     return NULL;
 201 #endif
 202 }
 203
 204 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 205 /*
 206  *
 207  */
 208
 209 static int
 210 cc_des_cbc_init(EVP_CIPHER_CTX *ctx,
 211                 const unsigned char * key,
 212                 const unsigned char * iv,
 213                 int encp)
 214 {
 215     struct cc_key *cc = ctx->cipher_data;
 216     return init_cc_key(encp, kCCAlgorithmDES, 0, key, kCCBlockSizeDES, iv, &cc->href);
 217 }
 218 #endif
 219
 220 /**
 221  * The DES cipher type (Apple CommonCrypto provider)
 222  *
 223  * @return the DES-CBC EVP_CIPHER pointer.
 224  *
 225  * @ingroup hcrypto_evp
 226  */
 227
 228 const EVP_CIPHER *
 229 EVP_cc_des_cbc(void)
 230 {
 231 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 232     static const EVP_CIPHER des_ede3_cbc = {
 233         0,
 234         kCCBlockSizeDES,
 235         kCCBlockSizeDES,
 236         kCCBlockSizeDES,
 237         EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 238         cc_des_cbc_init,
 239         cc_do_cipher,
 240         cc_cleanup,
 241         sizeof(struct cc_key),
 242         NULL,
 243         NULL,
 244         NULL,
 245         NULL
 246     };
 247     return &des_ede3_cbc;
 248 #else
 249     return NULL;
 250 #endif
 251 }
 252
 253 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 254 /*
 255  *
 256  */
 257
 258 static int
 259 cc_aes_cbc_init(EVP_CIPHER_CTX *ctx,
 260                 const unsigned char * key,
 261                 const unsigned char * iv,
 262                 int encp)
 263 {
 264     struct cc_key *cc = ctx->cipher_data;
 265     return init_cc_key(encp, kCCAlgorithmAES128, 0, key, ctx->cipher->key_len, iv, &cc->href);
 266 }
 267 #endif
 268
 269 /**
 270  * The AES-128 cipher type (Apple CommonCrypto provider)
 271  *
 272  * @return the AES-128-CBC EVP_CIPHER pointer.
 273  *
 274  * @ingroup hcrypto_evp
 275  */
 276
 277 const EVP_CIPHER *
 278 EVP_cc_aes_128_cbc(void)
 279 {
 280 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 281     static const EVP_CIPHER c = {
 282         0,
 283         kCCBlockSizeAES128,
 284         kCCKeySizeAES128,
 285         kCCBlockSizeAES128,
 286         EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 287         cc_aes_cbc_init,
 288         cc_do_cipher,
 289         cc_cleanup,
 290         sizeof(struct cc_key),
 291         NULL,
 292         NULL,
 293         NULL,
 294         NULL
 295     };
 296     return &c;
 297 #else
 298     return NULL;
 299 #endif
 300 }
 301
 302 /**
 303  * The AES-192 cipher type (Apple CommonCrypto provider)
 304  *
 305  * @return the AES-192-CBC EVP_CIPHER pointer.
 306  *
 307  * @ingroup hcrypto_evp
 308  */
 309
 310 const EVP_CIPHER *
 311 EVP_cc_aes_192_cbc(void)
 312 {
 313 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 314     static const EVP_CIPHER c = {
 315         0,
 316         kCCBlockSizeAES128,
 317         kCCKeySizeAES192,
 318         kCCBlockSizeAES128,
 319         EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 320         cc_aes_cbc_init,
 321         cc_do_cipher,
 322         cc_cleanup,
 323         sizeof(struct cc_key),
 324         NULL,
 325         NULL,
 326         NULL,
 327         NULL
 328     };
 329     return &c;
 330 #else
 331     return NULL;
 332 #endif
 333 }
 334
 335 /**
 336  * The AES-256 cipher type (Apple CommonCrypto provider)
 337  *
 338  * @return the AES-256-CBC EVP_CIPHER pointer.
 339  *
 340  * @ingroup hcrypto_evp
 341  */
 342
 343 const EVP_CIPHER *
 344 EVP_cc_aes_256_cbc(void)
 345 {
 346 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 347     static const EVP_CIPHER c = {
 348         0,
 349         kCCBlockSizeAES128,
 350         kCCKeySizeAES256,
 351         kCCBlockSizeAES128,
 352         EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 353         cc_aes_cbc_init,
 354         cc_do_cipher,
 355         cc_cleanup,
 356         sizeof(struct cc_key),
 357         NULL,
 358         NULL,
 359         NULL,
 360         NULL
 361     };
 362     return &c;
 363 #else
 364     return NULL;
 365 #endif
 366 }
 367
 368 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 369 /*
 370  *
 371  */
 372
 373 static int
 374 cc_aes_cfb8_init(EVP_CIPHER_CTX *ctx,
 375                 const unsigned char * key,
 376                 const unsigned char * iv,
 377                 int encp)
 378 {
 379     struct cc_key *cc = ctx->cipher_data;
 380     memcpy(ctx->iv, iv, ctx->cipher->iv_len);
 381     return init_cc_key(1, kCCAlgorithmAES128, kCCOptionECBMode,
 382                        key, ctx->cipher->key_len, NULL, &cc->href);
 383 }
 384 #endif
 385
 386 /**
 387  * The AES-128 CFB8 cipher type (Apple CommonCrypto provider)
 388  *
 389  * @return the AES-128-CFB8 EVP_CIPHER pointer.
 390  *
 391  * @ingroup hcrypto_evp
 392  */
 393
 394 const EVP_CIPHER *
 395 EVP_cc_aes_128_cfb8(void)
 396 {
 397 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 398     static const EVP_CIPHER c = {
 399         0,
 400         1,
 401         kCCKeySizeAES128,
 402         kCCBlockSizeAES128,
 403         EVP_CIPH_CFB8_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 404         cc_aes_cfb8_init,
 405         cc_do_cfb8_cipher,
 406         cc_cleanup,
 407         sizeof(struct cc_key),
 408         NULL,
 409         NULL,
 410         NULL,
 411         NULL
 412     };
 413     return &c;
 414 #else
 415     return NULL;
 416 #endif
 417 }
 418
 419 /**
 420  * The AES-192 CFB8 cipher type (Apple CommonCrypto provider)
 421  *
 422  * @return the AES-192-CFB8 EVP_CIPHER pointer.
 423  *
 424  * @ingroup hcrypto_evp
 425  */
 426
 427 const EVP_CIPHER *
 428 EVP_cc_aes_192_cfb8(void)
 429 {
 430 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 431     static const EVP_CIPHER c = {
 432         0,
 433         1,
 434         kCCKeySizeAES192,
 435         kCCBlockSizeAES128,
 436         EVP_CIPH_CFB8_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 437         cc_aes_cfb8_init,
 438         cc_do_cfb8_cipher,
 439         cc_cleanup,
 440         sizeof(struct cc_key),
 441         NULL,
 442         NULL,
 443         NULL,
 444         NULL
 445     };
 446     return &c;
 447 #else
 448     return NULL;
 449 #endif
 450 }
 451
 452 /**
 453  * The AES-256 CFB8 cipher type (Apple CommonCrypto provider)
 454  *
 455  * @return the AES-256-CFB8 EVP_CIPHER pointer.
 456  *
 457  * @ingroup hcrypto_evp
 458  */
 459
 460 const EVP_CIPHER *
 461 EVP_cc_aes_256_cfb8(void)
 462 {
 463 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 464     static const EVP_CIPHER c = {
 465         0,
 466         kCCBlockSizeAES128,
 467         kCCKeySizeAES256,
 468         kCCBlockSizeAES128,
 469         EVP_CIPH_CFB8_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 470         cc_aes_cfb8_init,
 471         cc_do_cfb8_cipher,
 472         cc_cleanup,
 473         sizeof(struct cc_key),
 474         NULL,
 475         NULL,
 476         NULL,
 477         NULL
 478     };
 479     return &c;
 480 #else
 481     return NULL;
 482 #endif
 483 }
 484
 485 /*
 486  *
 487  */
 488
 489 #ifdef COMMONCRYPTO_SUPPORTS_RC2
 490 static int
 491 cc_rc2_cbc_init(EVP_CIPHER_CTX *ctx,
 492                 const unsigned char * key,
 493                 const unsigned char * iv,
 494                 int encp)
 495 {
 496     struct cc_key *cc = ctx->cipher_data;
 497     return init_cc_key(encp, kCCAlgorithmRC2, 0, key, ctx->cipher->key_len, iv, &cc->href);
 498 }
 499 #endif
 500
 501 /**
 502  * The RC2 cipher type - common crypto
 503  *
 504  * @return the RC2 EVP_CIPHER pointer.
 505  *
 506  * @ingroup hcrypto_evp
 507  */
 508
 509
 510 const EVP_CIPHER *
 511 EVP_cc_rc2_cbc(void)
 512 {
 513 #ifdef COMMONCRYPTO_SUPPORTS_RC2
 514     static const EVP_CIPHER rc2_cbc = {
 515         0,
 516         kCCBlockSizeRC2,
 517         16,
 518         kCCBlockSizeRC2,
 519         EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 520         cc_rc2_cbc_init,
 521         cc_do_cipher,
 522         cc_cleanup,
 523         sizeof(struct cc_key),
 524         NULL,
 525         NULL,
 526         NULL,
 527         NULL
 528     };
 529     return &rc2_cbc;
 530 #else
 531     return NULL;
 532 #endif
 533 }
 534
 535 /**
 536  * The RC2-40 cipher type - common crypto
 537  *
 538  * @return the RC2-40 EVP_CIPHER pointer.
 539  *
 540  * @ingroup hcrypto_evp
 541  */
 542
 543
 544 const EVP_CIPHER *
 545 EVP_cc_rc2_40_cbc(void)
 546 {
 547 #ifdef COMMONCRYPTO_SUPPORTS_RC2
 548     static const EVP_CIPHER rc2_40_cbc = {
 549         0,
 550         kCCBlockSizeRC2,
 551         5,
 552         kCCBlockSizeRC2,
 553         EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 554         cc_rc2_cbc_init,
 555         cc_do_cipher,
 556         cc_cleanup,
 557         sizeof(struct cc_key),
 558         NULL,
 559         NULL,
 560         NULL,
 561         NULL
 562     };
 563     return &rc2_40_cbc;
 564 #else
 565     return NULL;
 566 #endif
 567 }
 568
 569
 570 /**
 571  * The RC2-64 cipher type - common crypto
 572  *
 573  * @return the RC2-64 EVP_CIPHER pointer.
 574  *
 575  * @ingroup hcrypto_evp
 576  */
 577
 578
 579 const EVP_CIPHER *
 580 EVP_cc_rc2_64_cbc(void)
 581 {
 582 #ifdef COMMONCRYPTO_SUPPORTS_RC2
 583     static const EVP_CIPHER rc2_64_cbc = {
 584         0,
 585         kCCBlockSizeRC2,
 586         8,
 587         kCCBlockSizeRC2,
 588         EVP_CIPH_CBC_MODE|EVP_CIPH_ALWAYS_CALL_INIT,
 589         cc_rc2_cbc_init,
 590         cc_do_cipher,
 591         cc_cleanup,
 592         sizeof(struct cc_key),
 593         NULL,
 594         NULL,
 595         NULL,
 596         NULL
 597     };
 598     return &rc2_64_cbc;
 599 #else
 600     return NULL;
 601 #endif
 602 }
 603
 604 /**
 605  * The CommonCrypto md2 provider
 606  *
 607  * @ingroup hcrypto_evp
 608  */
 609
 610 const EVP_MD *
 611 EVP_cc_md2(void)
 612 {
 613 #ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
 614     static const struct hc_evp_md md2 = {
 615         CC_MD2_DIGEST_LENGTH,
 616         CC_MD2_BLOCK_BYTES,
 617         sizeof(CC_MD2_CTX),
 618         (hc_evp_md_init)CC_MD2_Init,
 619         (hc_evp_md_update)CC_MD2_Update,
 620         (hc_evp_md_final)CC_MD2_Final,
 621         (hc_evp_md_cleanup)NULL
 622     };
 623     return &md2;
 624 #else
 625     return NULL;
 626 #endif
 627 }
 628
 629 /**
 630  * The CommonCrypto md4 provider
 631  *
 632  * @ingroup hcrypto_evp
 633  */
 634
 635 const EVP_MD *
 636 EVP_cc_md4(void)
 637 {
 638 #ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
 639     static const struct hc_evp_md md4 = {
 640         CC_MD4_DIGEST_LENGTH,
 641         CC_MD4_BLOCK_BYTES,
 642         sizeof(CC_MD4_CTX),
 643         (hc_evp_md_init)CC_MD4_Init,
 644         (hc_evp_md_update)CC_MD4_Update,
 645         (hc_evp_md_final)CC_MD4_Final,
 646         (hc_evp_md_cleanup)NULL
 647     };
 648     return &md4;
 649 #else
 650     return NULL;
 651 #endif
 652 }
 653
 654 /**
 655  * The CommonCrypto md5 provider
 656  *
 657  * @ingroup hcrypto_evp
 658  */
 659
 660 const EVP_MD *
 661 EVP_cc_md5(void)
 662 {
 663 #ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
 664     static const struct hc_evp_md md5 = {
 665         CC_MD5_DIGEST_LENGTH,
 666         CC_MD5_BLOCK_BYTES,
 667         sizeof(CC_MD5_CTX),
 668         (hc_evp_md_init)CC_MD5_Init,
 669         (hc_evp_md_update)CC_MD5_Update,
 670         (hc_evp_md_final)CC_MD5_Final,
 671         (hc_evp_md_cleanup)NULL
 672     };
 673     return &md5;
 674 #else
 675     return NULL;
 676 #endif
 677 }
 678
 679 /**
 680  * The CommonCrypto sha1 provider
 681  *
 682  * @ingroup hcrypto_evp
 683  */
 684
 685 const EVP_MD *
 686 EVP_cc_sha1(void)
 687 {
 688 #ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
 689     static const struct hc_evp_md sha1 = {
 690         CC_SHA1_DIGEST_LENGTH,
 691         CC_SHA1_BLOCK_BYTES,
 692         sizeof(CC_SHA1_CTX),
 693         (hc_evp_md_init)CC_SHA1_Init,
 694         (hc_evp_md_update)CC_SHA1_Update,
 695         (hc_evp_md_final)CC_SHA1_Final,
 696         (hc_evp_md_cleanup)NULL
 697     };
 698     return &sha1;
 699 #else
 700     return NULL;
 701 #endif
 702 }
 703
 704 /**
 705  * The CommonCrypto sha256 provider
 706  *
 707  * @ingroup hcrypto_evp
 708  */
 709
 710 const EVP_MD *
 711 EVP_cc_sha256(void)
 712 {
 713 #ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
 714     static const struct hc_evp_md sha256 = {
 715         CC_SHA256_DIGEST_LENGTH,
 716         CC_SHA256_BLOCK_BYTES,
 717         sizeof(CC_SHA256_CTX),
 718         (hc_evp_md_init)CC_SHA256_Init,
 719         (hc_evp_md_update)CC_SHA256_Update,
 720         (hc_evp_md_final)CC_SHA256_Final,
 721         (hc_evp_md_cleanup)NULL
 722     };
 723     return &sha256;
 724 #else
 725     return NULL;
 726 #endif
 727 }
 728
 729 /**
 730  * The Camellia-128 cipher type - CommonCrypto
 731  *
 732  * @return the Camellia-128 EVP_CIPHER pointer.
 733  *
 734  * @ingroup hcrypto_evp
 735  */
 736
 737 const EVP_CIPHER *
 738 EVP_cc_camellia_128_cbc(void)
 739 {
 740     return NULL;
 741 }
 742
 743 /**
 744  * The Camellia-198 cipher type - CommonCrypto
 745  *
 746  * @return the Camellia-198 EVP_CIPHER pointer.
 747  *
 748  * @ingroup hcrypto_evp
 749  */
 750
 751 const EVP_CIPHER *
 752 EVP_cc_camellia_192_cbc(void)
 753 {
 754     return NULL;
 755 }
 756
 757 /**
 758  * The Camellia-256 cipher type - CommonCrypto
 759  *
 760  * @return the Camellia-256 EVP_CIPHER pointer.
 761  *
 762  * @ingroup hcrypto_evp
 763  */
 764
 765 const EVP_CIPHER *
 766 EVP_cc_camellia_256_cbc(void)
 767 {
 768     return NULL;
 769 }
 770
 771 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 772
 773 /*
 774  *
 775  */
 776
 777 static int
 778 cc_rc4_init(EVP_CIPHER_CTX *ctx,
 779             const unsigned char * key,
 780             const unsigned char * iv,
 781             int encp)
 782 {
 783     struct cc_key *cc = ctx->cipher_data;
 784     return init_cc_key(encp, kCCAlgorithmRC4, 0, key, ctx->key_len, iv, &cc->href);
 785 }
 786
 787 #endif
 788
 789 /**
 790
 791  * The RC4 cipher type (Apple CommonCrypto provider)
 792  *
 793  * @return the RC4 EVP_CIPHER pointer.
 794  *
 795  * @ingroup hcrypto_evp
 796  */
 797
 798 const EVP_CIPHER *
 799 EVP_cc_rc4(void)
 800 {
 801 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 802     static const EVP_CIPHER rc4 = {
 803         0,
 804         1,
 805         16,
 806         0,
 807         EVP_CIPH_STREAM_CIPHER|EVP_CIPH_VARIABLE_LENGTH,
 808         cc_rc4_init,
 809         cc_do_cipher,
 810         cc_cleanup,
 811         sizeof(struct cc_key),
 812         NULL,
 813         NULL,
 814         NULL,
 815         NULL
 816     };
 817     return &rc4;
 818 #else
 819     return NULL;
 820 #endif
 821 }
 822
 823
 824 /**
 825  * The RC4-40 cipher type (Apple CommonCrypto provider)
 826  *
 827  * @return the RC4 EVP_CIPHER pointer.
 828  *
 829  * @ingroup hcrypto_evp
 830  */
 831
 832 const EVP_CIPHER *
 833 EVP_cc_rc4_40(void)
 834 {
 835 #ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H
 836     static const EVP_CIPHER rc4_40 = {
 837         0,
 838         1,
 839         5,
 840         0,
 841         EVP_CIPH_STREAM_CIPHER|EVP_CIPH_VARIABLE_LENGTH,
 842         cc_rc4_init,
 843         cc_do_cipher,
 844         cc_cleanup,
 845         sizeof(struct cc_key),
 846         NULL,
 847         NULL,
 848         NULL,
 849         NULL
 850     };
 851     return &rc4_40;
 852 #else
 853     return NULL;
 854 #endif
 855 }
 856
 857 #endif /* __APPLE__ */
 858