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 66struct cc_key { 67 CCCryptorRef href; 68}; 69 70static int 71cc_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 92static int 93cc_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 129static int 130cc_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 138static int 139init_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 159static int 160cc_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 179const EVP_CIPHER * 180EVP_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 209static int 210cc_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 228const EVP_CIPHER * 229EVP_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 258static int 259cc_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 277const EVP_CIPHER * 278EVP_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 310const EVP_CIPHER * 311EVP_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 343const EVP_CIPHER * 344EVP_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 373static int 374cc_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 394const EVP_CIPHER * 395EVP_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 427const EVP_CIPHER * 428EVP_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 460const EVP_CIPHER * 461EVP_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 490static int 491cc_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 510const EVP_CIPHER * 511EVP_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 544const EVP_CIPHER * 545EVP_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 579const EVP_CIPHER * 580EVP_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 610const EVP_MD * 611EVP_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 635const EVP_MD * 636EVP_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 660const EVP_MD * 661EVP_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 685const EVP_MD * 686EVP_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 710const EVP_MD * 711EVP_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 737const EVP_CIPHER * 738EVP_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 751const EVP_CIPHER * 752EVP_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 765const EVP_CIPHER * 766EVP_cc_camellia_256_cbc(void) 767{ 768 return NULL; 769} 770 771#ifdef HAVE_COMMONCRYPTO_COMMONCRYPTOR_H 772 773/* 774 * 775 */ 776 777static int 778cc_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 798const EVP_CIPHER * 799EVP_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 832const EVP_CIPHER * 833EVP_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 859