1/*- 2* Copyright (c) 2003-2007 Tim Kientzle 3* Copyright (c) 2011 Andres Mejia 4* Copyright (c) 2011 Michihiro NAKAJIMA 5* All rights reserved. 6* 7* Redistribution and use in source and binary forms, with or without 8* modification, are permitted provided that the following conditions 9* are met: 10* 1. Redistributions of source code must retain the above copyright 11* notice, this list of conditions and the following disclaimer. 12* 2. Redistributions in binary form must reproduce the above copyright 13* notice, this list of conditions and the following disclaimer in the 14* documentation and/or other materials provided with the distribution. 15* 16* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 17* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 20* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26*/ 27 28#include "archive_platform.h" 29 30#include "archive.h" 31#include "archive_crypto_private.h" 32 33/* In particular, force the configure probe to break if it tries 34 * to test a combination of OpenSSL and libmd. */ 35#if defined(ARCHIVE_CRYPTO_OPENSSL) && defined(ARCHIVE_CRYPTO_LIBMD) 36#error Cannot use both OpenSSL and libmd. 37#endif 38 39/* 40 * Message digest functions for Windows platform. 41 */ 42#if defined(ARCHIVE_CRYPTO_MD5_WIN) ||\ 43 defined(ARCHIVE_CRYPTO_SHA1_WIN) ||\ 44 defined(ARCHIVE_CRYPTO_SHA256_WIN) ||\ 45 defined(ARCHIVE_CRYPTO_SHA384_WIN) ||\ 46 defined(ARCHIVE_CRYPTO_SHA512_WIN) 47 48/* 49 * Initialize a Message digest. 50 */ 51static int 52win_crypto_init(Digest_CTX *ctx, ALG_ID algId) 53{ 54 55 ctx->valid = 0; 56 if (!CryptAcquireContext(&ctx->cryptProv, NULL, NULL, 57 PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) { 58 if (GetLastError() != (DWORD)NTE_BAD_KEYSET) 59 return (ARCHIVE_FAILED); 60 if (!CryptAcquireContext(&ctx->cryptProv, NULL, NULL, 61 PROV_RSA_FULL, CRYPT_NEWKEYSET)) 62 return (ARCHIVE_FAILED); 63 } 64 65 if (!CryptCreateHash(ctx->cryptProv, algId, 0, 0, &ctx->hash)) { 66 CryptReleaseContext(ctx->cryptProv, 0); 67 return (ARCHIVE_FAILED); 68 } 69 70 ctx->valid = 1; 71 return (ARCHIVE_OK); 72} 73 74/* 75 * Update a Message digest. 76 */ 77static int 78win_crypto_Update(Digest_CTX *ctx, const unsigned char *buf, size_t len) 79{ 80 81 if (!ctx->valid) 82 return (ARCHIVE_FAILED); 83 84 CryptHashData(ctx->hash, 85 (unsigned char *)(uintptr_t)buf, 86 (DWORD)len, 0); 87 return (ARCHIVE_OK); 88} 89 90static int 91win_crypto_Final(unsigned char *buf, size_t bufsize, Digest_CTX *ctx) 92{ 93 DWORD siglen = (DWORD)bufsize; 94 95 if (!ctx->valid) 96 return (ARCHIVE_FAILED); 97 98 CryptGetHashParam(ctx->hash, HP_HASHVAL, buf, &siglen, 0); 99 CryptDestroyHash(ctx->hash); 100 CryptReleaseContext(ctx->cryptProv, 0); 101 ctx->valid = 0; 102 return (ARCHIVE_OK); 103} 104 105#endif /* defined(ARCHIVE_CRYPTO_*_WIN) */ 106 107 108/* MD5 implementations */ 109#if defined(ARCHIVE_CRYPTO_MD5_LIBC) 110 111static int 112__archive_libc_md5init(archive_md5_ctx *ctx) 113{ 114 MD5Init(ctx); 115 return (ARCHIVE_OK); 116} 117 118static int 119__archive_libc_md5update(archive_md5_ctx *ctx, const void *indata, 120 size_t insize) 121{ 122 MD5Update(ctx, indata, insize); 123 return (ARCHIVE_OK); 124} 125 126static int 127__archive_libc_md5final(archive_md5_ctx *ctx, void *md) 128{ 129 MD5Final(md, ctx); 130 return (ARCHIVE_OK); 131} 132 133#elif defined(ARCHIVE_CRYPTO_MD5_LIBMD) 134 135static int 136__archive_libmd_md5init(archive_md5_ctx *ctx) 137{ 138 MD5Init(ctx); 139 return (ARCHIVE_OK); 140} 141 142static int 143__archive_libmd_md5update(archive_md5_ctx *ctx, const void *indata, 144 size_t insize) 145{ 146 MD5Update(ctx, indata, insize); 147 return (ARCHIVE_OK); 148} 149 150static int 151__archive_libmd_md5final(archive_md5_ctx *ctx, void *md) 152{ 153 MD5Final(md, ctx); 154 return (ARCHIVE_OK); 155} 156 157#elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM) 158 159static int 160__archive_libsystem_md5init(archive_md5_ctx *ctx) 161{ 162 CC_MD5_Init(ctx); 163 return (ARCHIVE_OK); 164} 165 166static int 167__archive_libsystem_md5update(archive_md5_ctx *ctx, const void *indata, 168 size_t insize) 169{ 170 CC_MD5_Update(ctx, indata, insize); 171 return (ARCHIVE_OK); 172} 173 174static int 175__archive_libsystem_md5final(archive_md5_ctx *ctx, void *md) 176{ 177 CC_MD5_Final(md, ctx); 178 return (ARCHIVE_OK); 179} 180 181#elif defined(ARCHIVE_CRYPTO_MD5_NETTLE) 182 183static int 184__archive_nettle_md5init(archive_md5_ctx *ctx) 185{ 186 md5_init(ctx); 187 return (ARCHIVE_OK); 188} 189 190static int 191__archive_nettle_md5update(archive_md5_ctx *ctx, const void *indata, 192 size_t insize) 193{ 194 md5_update(ctx, insize, indata); 195 return (ARCHIVE_OK); 196} 197 198static int 199__archive_nettle_md5final(archive_md5_ctx *ctx, void *md) 200{ 201 md5_digest(ctx, MD5_DIGEST_SIZE, md); 202 return (ARCHIVE_OK); 203} 204 205#elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL) 206 207static int 208__archive_openssl_md5init(archive_md5_ctx *ctx) 209{ 210 EVP_DigestInit(ctx, EVP_md5()); 211 return (ARCHIVE_OK); 212} 213 214static int 215__archive_openssl_md5update(archive_md5_ctx *ctx, const void *indata, 216 size_t insize) 217{ 218 EVP_DigestUpdate(ctx, indata, insize); 219 return (ARCHIVE_OK); 220} 221 222static int 223__archive_openssl_md5final(archive_md5_ctx *ctx, void *md) 224{ 225 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so 226 * this is meant to cope with that. Real fix is probably to fix 227 * archive_write_set_format_xar.c 228 */ 229 if (ctx->digest) 230 EVP_DigestFinal(ctx, md, NULL); 231 return (ARCHIVE_OK); 232} 233 234#elif defined(ARCHIVE_CRYPTO_MD5_WIN) 235 236static int 237__archive_windowsapi_md5init(archive_md5_ctx *ctx) 238{ 239 return (win_crypto_init(ctx, CALG_MD5)); 240} 241 242static int 243__archive_windowsapi_md5update(archive_md5_ctx *ctx, const void *indata, 244 size_t insize) 245{ 246 return (win_crypto_Update(ctx, indata, insize)); 247} 248 249static int 250__archive_windowsapi_md5final(archive_md5_ctx *ctx, void *md) 251{ 252 return (win_crypto_Final(md, 16, ctx)); 253} 254 255#else 256 257static int 258__archive_stub_md5init(archive_md5_ctx *ctx) 259{ 260 (void)ctx; /* UNUSED */ 261 return (ARCHIVE_FAILED); 262} 263 264static int 265__archive_stub_md5update(archive_md5_ctx *ctx, const void *indata, 266 size_t insize) 267{ 268 (void)ctx; /* UNUSED */ 269 (void)indata; /* UNUSED */ 270 (void)insize; /* UNUSED */ 271 return (ARCHIVE_FAILED); 272} 273 274static int 275__archive_stub_md5final(archive_md5_ctx *ctx, void *md) 276{ 277 (void)ctx; /* UNUSED */ 278 (void)md; /* UNUSED */ 279 return (ARCHIVE_FAILED); 280} 281 282#endif 283 284/* RIPEMD160 implementations */ 285#if defined(ARCHIVE_CRYPTO_RMD160_LIBC) 286 287static int 288__archive_libc_ripemd160init(archive_rmd160_ctx *ctx) 289{ 290 RMD160Init(ctx); 291 return (ARCHIVE_OK); 292} 293 294static int 295__archive_libc_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 296 size_t insize) 297{ 298 RMD160Update(ctx, indata, insize); 299 return (ARCHIVE_OK); 300} 301 302static int 303__archive_libc_ripemd160final(archive_rmd160_ctx *ctx, void *md) 304{ 305 RMD160Final(md, ctx); 306 return (ARCHIVE_OK); 307} 308 309#elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD) 310 311static int 312__archive_libmd_ripemd160init(archive_rmd160_ctx *ctx) 313{ 314 RIPEMD160_Init(ctx); 315 return (ARCHIVE_OK); 316} 317 318static int 319__archive_libmd_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 320 size_t insize) 321{ 322 RIPEMD160_Update(ctx, indata, insize); 323 return (ARCHIVE_OK); 324} 325 326static int 327__archive_libmd_ripemd160final(archive_rmd160_ctx *ctx, void *md) 328{ 329 RIPEMD160_Final(md, ctx); 330 return (ARCHIVE_OK); 331} 332 333#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE) 334 335static int 336__archive_nettle_ripemd160init(archive_rmd160_ctx *ctx) 337{ 338 ripemd160_init(ctx); 339 return (ARCHIVE_OK); 340} 341 342static int 343__archive_nettle_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 344 size_t insize) 345{ 346 ripemd160_update(ctx, insize, indata); 347 return (ARCHIVE_OK); 348} 349 350static int 351__archive_nettle_ripemd160final(archive_rmd160_ctx *ctx, void *md) 352{ 353 ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md); 354 return (ARCHIVE_OK); 355} 356 357#elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL) 358 359static int 360__archive_openssl_ripemd160init(archive_rmd160_ctx *ctx) 361{ 362 EVP_DigestInit(ctx, EVP_ripemd160()); 363 return (ARCHIVE_OK); 364} 365 366static int 367__archive_openssl_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 368 size_t insize) 369{ 370 EVP_DigestUpdate(ctx, indata, insize); 371 return (ARCHIVE_OK); 372} 373 374static int 375__archive_openssl_ripemd160final(archive_rmd160_ctx *ctx, void *md) 376{ 377 EVP_DigestFinal(ctx, md, NULL); 378 return (ARCHIVE_OK); 379} 380 381#else 382 383static int 384__archive_stub_ripemd160init(archive_rmd160_ctx *ctx) 385{ 386 (void)ctx; /* UNUSED */ 387 return (ARCHIVE_FAILED); 388} 389 390static int 391__archive_stub_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 392 size_t insize) 393{ 394 (void)ctx; /* UNUSED */ 395 (void)indata; /* UNUSED */ 396 (void)insize; /* UNUSED */ 397 return (ARCHIVE_FAILED); 398} 399 400static int 401__archive_stub_ripemd160final(archive_rmd160_ctx *ctx, void *md) 402{ 403 (void)ctx; /* UNUSED */ 404 (void)md; /* UNUSED */ 405 return (ARCHIVE_FAILED); 406} 407 408#endif 409 410/* SHA1 implementations */ 411#if defined(ARCHIVE_CRYPTO_SHA1_LIBC) 412 413static int 414__archive_libc_sha1init(archive_sha1_ctx *ctx) 415{ 416 SHA1Init(ctx); 417 return (ARCHIVE_OK); 418} 419 420static int 421__archive_libc_sha1update(archive_sha1_ctx *ctx, const void *indata, 422 size_t insize) 423{ 424 SHA1Update(ctx, indata, insize); 425 return (ARCHIVE_OK); 426} 427 428static int 429__archive_libc_sha1final(archive_sha1_ctx *ctx, void *md) 430{ 431 SHA1Final(md, ctx); 432 return (ARCHIVE_OK); 433} 434 435#elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD) 436 437static int 438__archive_libmd_sha1init(archive_sha1_ctx *ctx) 439{ 440 SHA1_Init(ctx); 441 return (ARCHIVE_OK); 442} 443 444static int 445__archive_libmd_sha1update(archive_sha1_ctx *ctx, const void *indata, 446 size_t insize) 447{ 448 SHA1_Update(ctx, indata, insize); 449 return (ARCHIVE_OK); 450} 451 452static int 453__archive_libmd_sha1final(archive_sha1_ctx *ctx, void *md) 454{ 455 SHA1_Final(md, ctx); 456 return (ARCHIVE_OK); 457} 458 459#elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM) 460 461static int 462__archive_libsystem_sha1init(archive_sha1_ctx *ctx) 463{ 464 CC_SHA1_Init(ctx); 465 return (ARCHIVE_OK); 466} 467 468static int 469__archive_libsystem_sha1update(archive_sha1_ctx *ctx, const void *indata, 470 size_t insize) 471{ 472 CC_SHA1_Update(ctx, indata, insize); 473 return (ARCHIVE_OK); 474} 475 476static int 477__archive_libsystem_sha1final(archive_sha1_ctx *ctx, void *md) 478{ 479 CC_SHA1_Final(md, ctx); 480 return (ARCHIVE_OK); 481} 482 483#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE) 484 485static int 486__archive_nettle_sha1init(archive_sha1_ctx *ctx) 487{ 488 sha1_init(ctx); 489 return (ARCHIVE_OK); 490} 491 492static int 493__archive_nettle_sha1update(archive_sha1_ctx *ctx, const void *indata, 494 size_t insize) 495{ 496 sha1_update(ctx, insize, indata); 497 return (ARCHIVE_OK); 498} 499 500static int 501__archive_nettle_sha1final(archive_sha1_ctx *ctx, void *md) 502{ 503 sha1_digest(ctx, SHA1_DIGEST_SIZE, md); 504 return (ARCHIVE_OK); 505} 506 507#elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL) 508 509static int 510__archive_openssl_sha1init(archive_sha1_ctx *ctx) 511{ 512 EVP_DigestInit(ctx, EVP_sha1()); 513 return (ARCHIVE_OK); 514} 515 516static int 517__archive_openssl_sha1update(archive_sha1_ctx *ctx, const void *indata, 518 size_t insize) 519{ 520 EVP_DigestUpdate(ctx, indata, insize); 521 return (ARCHIVE_OK); 522} 523 524static int 525__archive_openssl_sha1final(archive_sha1_ctx *ctx, void *md) 526{ 527 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so 528 * this is meant to cope with that. Real fix is probably to fix 529 * archive_write_set_format_xar.c 530 */ 531 if (ctx->digest) 532 EVP_DigestFinal(ctx, md, NULL); 533 return (ARCHIVE_OK); 534} 535 536#elif defined(ARCHIVE_CRYPTO_SHA1_WIN) 537 538static int 539__archive_windowsapi_sha1init(archive_sha1_ctx *ctx) 540{ 541 return (win_crypto_init(ctx, CALG_SHA1)); 542} 543 544static int 545__archive_windowsapi_sha1update(archive_sha1_ctx *ctx, const void *indata, 546 size_t insize) 547{ 548 return (win_crypto_Update(ctx, indata, insize)); 549} 550 551static int 552__archive_windowsapi_sha1final(archive_sha1_ctx *ctx, void *md) 553{ 554 return (win_crypto_Final(md, 20, ctx)); 555} 556 557#else 558 559static int 560__archive_stub_sha1init(archive_sha1_ctx *ctx) 561{ 562 (void)ctx; /* UNUSED */ 563 return (ARCHIVE_FAILED); 564} 565 566static int 567__archive_stub_sha1update(archive_sha1_ctx *ctx, const void *indata, 568 size_t insize) 569{ 570 (void)ctx; /* UNUSED */ 571 (void)indata; /* UNUSED */ 572 (void)insize; /* UNUSED */ 573 return (ARCHIVE_FAILED); 574} 575 576static int 577__archive_stub_sha1final(archive_sha1_ctx *ctx, void *md) 578{ 579 (void)ctx; /* UNUSED */ 580 (void)md; /* UNUSED */ 581 return (ARCHIVE_FAILED); 582} 583 584#endif 585 586/* SHA256 implementations */ 587#if defined(ARCHIVE_CRYPTO_SHA256_LIBC) 588 589static int 590__archive_libc_sha256init(archive_sha256_ctx *ctx) 591{ 592 SHA256_Init(ctx); 593 return (ARCHIVE_OK); 594} 595 596static int 597__archive_libc_sha256update(archive_sha256_ctx *ctx, const void *indata, 598 size_t insize) 599{ 600 SHA256_Update(ctx, indata, insize); 601 return (ARCHIVE_OK); 602} 603 604static int 605__archive_libc_sha256final(archive_sha256_ctx *ctx, void *md) 606{ 607 SHA256_Final(md, ctx); 608 return (ARCHIVE_OK); 609} 610 611#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2) 612 613static int 614__archive_libc2_sha256init(archive_sha256_ctx *ctx) 615{ 616 SHA256Init(ctx); 617 return (ARCHIVE_OK); 618} 619 620static int 621__archive_libc2_sha256update(archive_sha256_ctx *ctx, const void *indata, 622 size_t insize) 623{ 624 SHA256Update(ctx, indata, insize); 625 return (ARCHIVE_OK); 626} 627 628static int 629__archive_libc2_sha256final(archive_sha256_ctx *ctx, void *md) 630{ 631 SHA256Final(md, ctx); 632 return (ARCHIVE_OK); 633} 634 635#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3) 636 637static int 638__archive_libc3_sha256init(archive_sha256_ctx *ctx) 639{ 640 SHA256Init(ctx); 641 return (ARCHIVE_OK); 642} 643 644static int 645__archive_libc3_sha256update(archive_sha256_ctx *ctx, const void *indata, 646 size_t insize) 647{ 648 SHA256Update(ctx, indata, insize); 649 return (ARCHIVE_OK); 650} 651 652static int 653__archive_libc3_sha256final(archive_sha256_ctx *ctx, void *md) 654{ 655 SHA256Final(md, ctx); 656 return (ARCHIVE_OK); 657} 658 659#elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD) 660 661static int 662__archive_libmd_sha256init(archive_sha256_ctx *ctx) 663{ 664 SHA256_Init(ctx); 665 return (ARCHIVE_OK); 666} 667 668static int 669__archive_libmd_sha256update(archive_sha256_ctx *ctx, const void *indata, 670 size_t insize) 671{ 672 SHA256_Update(ctx, indata, insize); 673 return (ARCHIVE_OK); 674} 675 676static int 677__archive_libmd_sha256final(archive_sha256_ctx *ctx, void *md) 678{ 679 SHA256_Final(md, ctx); 680 return (ARCHIVE_OK); 681} 682 683#elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM) 684 685static int 686__archive_libsystem_sha256init(archive_sha256_ctx *ctx) 687{ 688 CC_SHA256_Init(ctx); 689 return (ARCHIVE_OK); 690} 691 692static int 693__archive_libsystem_sha256update(archive_sha256_ctx *ctx, const void *indata, 694 size_t insize) 695{ 696 CC_SHA256_Update(ctx, indata, insize); 697 return (ARCHIVE_OK); 698} 699 700static int 701__archive_libsystem_sha256final(archive_sha256_ctx *ctx, void *md) 702{ 703 CC_SHA256_Final(md, ctx); 704 return (ARCHIVE_OK); 705} 706 707#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE) 708 709static int 710__archive_nettle_sha256init(archive_sha256_ctx *ctx) 711{ 712 sha256_init(ctx); 713 return (ARCHIVE_OK); 714} 715 716static int 717__archive_nettle_sha256update(archive_sha256_ctx *ctx, const void *indata, 718 size_t insize) 719{ 720 sha256_update(ctx, insize, indata); 721 return (ARCHIVE_OK); 722} 723 724static int 725__archive_nettle_sha256final(archive_sha256_ctx *ctx, void *md) 726{ 727 sha256_digest(ctx, SHA256_DIGEST_SIZE, md); 728 return (ARCHIVE_OK); 729} 730 731#elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL) 732 733static int 734__archive_openssl_sha256init(archive_sha256_ctx *ctx) 735{ 736 EVP_DigestInit(ctx, EVP_sha256()); 737 return (ARCHIVE_OK); 738} 739 740static int 741__archive_openssl_sha256update(archive_sha256_ctx *ctx, const void *indata, 742 size_t insize) 743{ 744 EVP_DigestUpdate(ctx, indata, insize); 745 return (ARCHIVE_OK); 746} 747 748static int 749__archive_openssl_sha256final(archive_sha256_ctx *ctx, void *md) 750{ 751 EVP_DigestFinal(ctx, md, NULL); 752 return (ARCHIVE_OK); 753} 754 755#elif defined(ARCHIVE_CRYPTO_SHA256_WIN) 756 757static int 758__archive_windowsapi_sha256init(archive_sha256_ctx *ctx) 759{ 760 return (win_crypto_init(ctx, CALG_SHA_256)); 761} 762 763static int 764__archive_windowsapi_sha256update(archive_sha256_ctx *ctx, const void *indata, 765 size_t insize) 766{ 767 return (win_crypto_Update(ctx, indata, insize)); 768} 769 770static int 771__archive_windowsapi_sha256final(archive_sha256_ctx *ctx, void *md) 772{ 773 return (win_crypto_Final(md, 32, ctx)); 774} 775 776#else 777 778static int 779__archive_stub_sha256init(archive_sha256_ctx *ctx) 780{ 781 (void)ctx; /* UNUSED */ 782 return (ARCHIVE_FAILED); 783} 784 785static int 786__archive_stub_sha256update(archive_sha256_ctx *ctx, const void *indata, 787 size_t insize) 788{ 789 (void)ctx; /* UNUSED */ 790 (void)indata; /* UNUSED */ 791 (void)insize; /* UNUSED */ 792 return (ARCHIVE_FAILED); 793} 794 795static int 796__archive_stub_sha256final(archive_sha256_ctx *ctx, void *md) 797{ 798 (void)ctx; /* UNUSED */ 799 (void)md; /* UNUSED */ 800 return (ARCHIVE_FAILED); 801} 802 803#endif 804 805/* SHA384 implementations */ 806#if defined(ARCHIVE_CRYPTO_SHA384_LIBC) 807 808static int 809__archive_libc_sha384init(archive_sha384_ctx *ctx) 810{ 811 SHA384_Init(ctx); 812 return (ARCHIVE_OK); 813} 814 815static int 816__archive_libc_sha384update(archive_sha384_ctx *ctx, const void *indata, 817 size_t insize) 818{ 819 SHA384_Update(ctx, indata, insize); 820 return (ARCHIVE_OK); 821} 822 823static int 824__archive_libc_sha384final(archive_sha384_ctx *ctx, void *md) 825{ 826 SHA384_Final(md, ctx); 827 return (ARCHIVE_OK); 828} 829 830#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2) 831 832static int 833__archive_libc2_sha384init(archive_sha384_ctx *ctx) 834{ 835 SHA384Init(ctx); 836 return (ARCHIVE_OK); 837} 838 839static int 840__archive_libc2_sha384update(archive_sha384_ctx *ctx, const void *indata, 841 size_t insize) 842{ 843 SHA384Update(ctx, indata, insize); 844 return (ARCHIVE_OK); 845} 846 847static int 848__archive_libc2_sha384final(archive_sha384_ctx *ctx, void *md) 849{ 850 SHA384Final(md, ctx); 851 return (ARCHIVE_OK); 852} 853 854#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3) 855 856static int 857__archive_libc3_sha384init(archive_sha384_ctx *ctx) 858{ 859 SHA384Init(ctx); 860 return (ARCHIVE_OK); 861} 862 863static int 864__archive_libc3_sha384update(archive_sha384_ctx *ctx, const void *indata, 865 size_t insize) 866{ 867 SHA384Update(ctx, indata, insize); 868 return (ARCHIVE_OK); 869} 870 871static int 872__archive_libc3_sha384final(archive_sha384_ctx *ctx, void *md) 873{ 874 SHA384Final(md, ctx); 875 return (ARCHIVE_OK); 876} 877 878#elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM) 879 880static int 881__archive_libsystem_sha384init(archive_sha384_ctx *ctx) 882{ 883 CC_SHA384_Init(ctx); 884 return (ARCHIVE_OK); 885} 886 887static int 888__archive_libsystem_sha384update(archive_sha384_ctx *ctx, const void *indata, 889 size_t insize) 890{ 891 CC_SHA384_Update(ctx, indata, insize); 892 return (ARCHIVE_OK); 893} 894 895static int 896__archive_libsystem_sha384final(archive_sha384_ctx *ctx, void *md) 897{ 898 CC_SHA384_Final(md, ctx); 899 return (ARCHIVE_OK); 900} 901 902#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE) 903 904static int 905__archive_nettle_sha384init(archive_sha384_ctx *ctx) 906{ 907 sha384_init(ctx); 908 return (ARCHIVE_OK); 909} 910 911static int 912__archive_nettle_sha384update(archive_sha384_ctx *ctx, const void *indata, 913 size_t insize) 914{ 915 sha384_update(ctx, insize, indata); 916 return (ARCHIVE_OK); 917} 918 919static int 920__archive_nettle_sha384final(archive_sha384_ctx *ctx, void *md) 921{ 922 sha384_digest(ctx, SHA384_DIGEST_SIZE, md); 923 return (ARCHIVE_OK); 924} 925 926#elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL) 927 928static int 929__archive_openssl_sha384init(archive_sha384_ctx *ctx) 930{ 931 EVP_DigestInit(ctx, EVP_sha384()); 932 return (ARCHIVE_OK); 933} 934 935static int 936__archive_openssl_sha384update(archive_sha384_ctx *ctx, const void *indata, 937 size_t insize) 938{ 939 EVP_DigestUpdate(ctx, indata, insize); 940 return (ARCHIVE_OK); 941} 942 943static int 944__archive_openssl_sha384final(archive_sha384_ctx *ctx, void *md) 945{ 946 EVP_DigestFinal(ctx, md, NULL); 947 return (ARCHIVE_OK); 948} 949 950#elif defined(ARCHIVE_CRYPTO_SHA384_WIN) 951 952static int 953__archive_windowsapi_sha384init(archive_sha384_ctx *ctx) 954{ 955 return (win_crypto_init(ctx, CALG_SHA_384)); 956} 957 958static int 959__archive_windowsapi_sha384update(archive_sha384_ctx *ctx, const void *indata, 960 size_t insize) 961{ 962 return (win_crypto_Update(ctx, indata, insize)); 963} 964 965static int 966__archive_windowsapi_sha384final(archive_sha384_ctx *ctx, void *md) 967{ 968 return (win_crypto_Final(md, 48, ctx)); 969} 970 971#else 972 973static int 974__archive_stub_sha384init(archive_sha384_ctx *ctx) 975{ 976 (void)ctx; /* UNUSED */ 977 return (ARCHIVE_FAILED); 978} 979 980static int 981__archive_stub_sha384update(archive_sha384_ctx *ctx, const void *indata, 982 size_t insize) 983{ 984 (void)ctx; /* UNUSED */ 985 (void)indata; /* UNUSED */ 986 (void)insize; /* UNUSED */ 987 return (ARCHIVE_FAILED); 988} 989 990static int 991__archive_stub_sha384final(archive_sha384_ctx *ctx, void *md) 992{ 993 (void)ctx; /* UNUSED */ 994 (void)md; /* UNUSED */ 995 return (ARCHIVE_FAILED); 996} 997 998#endif 999 1000/* SHA512 implementations */ 1001#if defined(ARCHIVE_CRYPTO_SHA512_LIBC) 1002 1003static int 1004__archive_libc_sha512init(archive_sha512_ctx *ctx) 1005{ 1006 SHA512_Init(ctx); 1007 return (ARCHIVE_OK); 1008} 1009 1010static int 1011__archive_libc_sha512update(archive_sha512_ctx *ctx, const void *indata, 1012 size_t insize) 1013{ 1014 SHA512_Update(ctx, indata, insize); 1015 return (ARCHIVE_OK); 1016} 1017 1018static int 1019__archive_libc_sha512final(archive_sha512_ctx *ctx, void *md) 1020{ 1021 SHA512_Final(md, ctx); 1022 return (ARCHIVE_OK); 1023} 1024 1025#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2) 1026 1027static int 1028__archive_libc2_sha512init(archive_sha512_ctx *ctx) 1029{ 1030 SHA512Init(ctx); 1031 return (ARCHIVE_OK); 1032} 1033 1034static int 1035__archive_libc2_sha512update(archive_sha512_ctx *ctx, const void *indata, 1036 size_t insize) 1037{ 1038 SHA512Update(ctx, indata, insize); 1039 return (ARCHIVE_OK); 1040} 1041 1042static int 1043__archive_libc2_sha512final(archive_sha512_ctx *ctx, void *md) 1044{ 1045 SHA512Final(md, ctx); 1046 return (ARCHIVE_OK); 1047} 1048 1049#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3) 1050 1051static int 1052__archive_libc3_sha512init(archive_sha512_ctx *ctx) 1053{ 1054 SHA512Init(ctx); 1055 return (ARCHIVE_OK); 1056} 1057 1058static int 1059__archive_libc3_sha512update(archive_sha512_ctx *ctx, const void *indata, 1060 size_t insize) 1061{ 1062 SHA512Update(ctx, indata, insize); 1063 return (ARCHIVE_OK); 1064} 1065 1066static int 1067__archive_libc3_sha512final(archive_sha512_ctx *ctx, void *md) 1068{ 1069 SHA512Final(md, ctx); 1070 return (ARCHIVE_OK); 1071} 1072 1073#elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD) 1074 1075static int 1076__archive_libmd_sha512init(archive_sha512_ctx *ctx) 1077{ 1078 SHA512_Init(ctx); 1079 return (ARCHIVE_OK); 1080} 1081 1082static int 1083__archive_libmd_sha512update(archive_sha512_ctx *ctx, const void *indata, 1084 size_t insize) 1085{ 1086 SHA512_Update(ctx, indata, insize); 1087 return (ARCHIVE_OK); 1088} 1089 1090static int 1091__archive_libmd_sha512final(archive_sha512_ctx *ctx, void *md) 1092{ 1093 SHA512_Final(md, ctx); 1094 return (ARCHIVE_OK); 1095} 1096 1097#elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM) 1098 1099static int 1100__archive_libsystem_sha512init(archive_sha512_ctx *ctx) 1101{ 1102 CC_SHA512_Init(ctx); 1103 return (ARCHIVE_OK); 1104} 1105 1106static int 1107__archive_libsystem_sha512update(archive_sha512_ctx *ctx, const void *indata, 1108 size_t insize) 1109{ 1110 CC_SHA512_Update(ctx, indata, insize); 1111 return (ARCHIVE_OK); 1112} 1113 1114static int 1115__archive_libsystem_sha512final(archive_sha512_ctx *ctx, void *md) 1116{ 1117 CC_SHA512_Final(md, ctx); 1118 return (ARCHIVE_OK); 1119} 1120 1121#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE) 1122 1123static int 1124__archive_nettle_sha512init(archive_sha512_ctx *ctx) 1125{ 1126 sha512_init(ctx); 1127 return (ARCHIVE_OK); 1128} 1129 1130static int 1131__archive_nettle_sha512update(archive_sha512_ctx *ctx, const void *indata, 1132 size_t insize) 1133{ 1134 sha512_update(ctx, insize, indata); 1135 return (ARCHIVE_OK); 1136} 1137 1138static int 1139__archive_nettle_sha512final(archive_sha512_ctx *ctx, void *md) 1140{ 1141 sha512_digest(ctx, SHA512_DIGEST_SIZE, md); 1142 return (ARCHIVE_OK); 1143} 1144 1145#elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL) 1146 1147static int 1148__archive_openssl_sha512init(archive_sha512_ctx *ctx) 1149{ 1150 EVP_DigestInit(ctx, EVP_sha512()); 1151 return (ARCHIVE_OK); 1152} 1153 1154static int 1155__archive_openssl_sha512update(archive_sha512_ctx *ctx, const void *indata, 1156 size_t insize) 1157{ 1158 EVP_DigestUpdate(ctx, indata, insize); 1159 return (ARCHIVE_OK); 1160} 1161 1162static int 1163__archive_openssl_sha512final(archive_sha512_ctx *ctx, void *md) 1164{ 1165 EVP_DigestFinal(ctx, md, NULL); 1166 return (ARCHIVE_OK); 1167} 1168 1169#elif defined(ARCHIVE_CRYPTO_SHA512_WIN) 1170 1171static int 1172__archive_windowsapi_sha512init(archive_sha512_ctx *ctx) 1173{ 1174 return (win_crypto_init(ctx, CALG_SHA_512)); 1175} 1176 1177static int 1178__archive_windowsapi_sha512update(archive_sha512_ctx *ctx, const void *indata, 1179 size_t insize) 1180{ 1181 return (win_crypto_Update(ctx, indata, insize)); 1182} 1183 1184static int 1185__archive_windowsapi_sha512final(archive_sha512_ctx *ctx, void *md) 1186{ 1187 return (win_crypto_Final(md, 64, ctx)); 1188} 1189 1190#else 1191 1192static int 1193__archive_stub_sha512init(archive_sha512_ctx *ctx) 1194{ 1195 (void)ctx; /* UNUSED */ 1196 return (ARCHIVE_FAILED); 1197} 1198 1199static int 1200__archive_stub_sha512update(archive_sha512_ctx *ctx, const void *indata, 1201 size_t insize) 1202{ 1203 (void)ctx; /* UNUSED */ 1204 (void)indata; /* UNUSED */ 1205 (void)insize; /* UNUSED */ 1206 return (ARCHIVE_FAILED); 1207} 1208 1209static int 1210__archive_stub_sha512final(archive_sha512_ctx *ctx, void *md) 1211{ 1212 (void)ctx; /* UNUSED */ 1213 (void)md; /* UNUSED */ 1214 return (ARCHIVE_FAILED); 1215} 1216 1217#endif 1218 1219/* NOTE: Crypto functions are set based on availability and by the following 1220 * order of preference. 1221 * 1. libc 1222 * 2. libc2 1223 * 3. libc3 1224 * 4. libSystem 1225 * 5. Nettle 1226 * 6. OpenSSL 1227 * 7. libmd 1228 * 8. Windows API 1229 */ 1230const struct archive_crypto __archive_crypto = 1231{ 1232/* MD5 */ 1233#if defined(ARCHIVE_CRYPTO_MD5_LIBC) 1234 &__archive_libc_md5init, 1235 &__archive_libc_md5update, 1236 &__archive_libc_md5final, 1237#elif defined(ARCHIVE_CRYPTO_MD5_LIBMD) 1238 &__archive_libmd_md5init, 1239 &__archive_libmd_md5update, 1240 &__archive_libmd_md5final, 1241#elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM) 1242 &__archive_libsystem_md5init, 1243 &__archive_libsystem_md5update, 1244 &__archive_libsystem_md5final, 1245#elif defined(ARCHIVE_CRYPTO_MD5_NETTLE) 1246 &__archive_nettle_md5init, 1247 &__archive_nettle_md5update, 1248 &__archive_nettle_md5final, 1249#elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL) 1250 &__archive_openssl_md5init, 1251 &__archive_openssl_md5update, 1252 &__archive_openssl_md5final, 1253#elif defined(ARCHIVE_CRYPTO_MD5_WIN) 1254 &__archive_windowsapi_md5init, 1255 &__archive_windowsapi_md5update, 1256 &__archive_windowsapi_md5final, 1257#elif !defined(ARCHIVE_MD5_COMPILE_TEST) 1258 &__archive_stub_md5init, 1259 &__archive_stub_md5update, 1260 &__archive_stub_md5final, 1261#endif 1262 1263/* RIPEMD160 */ 1264#if defined(ARCHIVE_CRYPTO_RMD160_LIBC) 1265 &__archive_libc_ripemd160init, 1266 &__archive_libc_ripemd160update, 1267 &__archive_libc_ripemd160final, 1268#elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD) 1269 &__archive_libmd_ripemd160init, 1270 &__archive_libmd_ripemd160update, 1271 &__archive_libmd_ripemd160final, 1272#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE) 1273 &__archive_nettle_ripemd160init, 1274 &__archive_nettle_ripemd160update, 1275 &__archive_nettle_ripemd160final, 1276#elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL) 1277 &__archive_openssl_ripemd160init, 1278 &__archive_openssl_ripemd160update, 1279 &__archive_openssl_ripemd160final, 1280#elif !defined(ARCHIVE_RMD160_COMPILE_TEST) 1281 &__archive_stub_ripemd160init, 1282 &__archive_stub_ripemd160update, 1283 &__archive_stub_ripemd160final, 1284#endif 1285 1286/* SHA1 */ 1287#if defined(ARCHIVE_CRYPTO_SHA1_LIBC) 1288 &__archive_libc_sha1init, 1289 &__archive_libc_sha1update, 1290 &__archive_libc_sha1final, 1291#elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD) 1292 &__archive_libmd_sha1init, 1293 &__archive_libmd_sha1update, 1294 &__archive_libmd_sha1final, 1295#elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM) 1296 &__archive_libsystem_sha1init, 1297 &__archive_libsystem_sha1update, 1298 &__archive_libsystem_sha1final, 1299#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE) 1300 &__archive_nettle_sha1init, 1301 &__archive_nettle_sha1update, 1302 &__archive_nettle_sha1final, 1303#elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL) 1304 &__archive_openssl_sha1init, 1305 &__archive_openssl_sha1update, 1306 &__archive_openssl_sha1final, 1307#elif defined(ARCHIVE_CRYPTO_SHA1_WIN) 1308 &__archive_windowsapi_sha1init, 1309 &__archive_windowsapi_sha1update, 1310 &__archive_windowsapi_sha1final, 1311#elif !defined(ARCHIVE_SHA1_COMPILE_TEST) 1312 &__archive_stub_sha1init, 1313 &__archive_stub_sha1update, 1314 &__archive_stub_sha1final, 1315#endif 1316 1317/* SHA256 */ 1318#if defined(ARCHIVE_CRYPTO_SHA256_LIBC) 1319 &__archive_libc_sha256init, 1320 &__archive_libc_sha256update, 1321 &__archive_libc_sha256final, 1322#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2) 1323 &__archive_libc2_sha256init, 1324 &__archive_libc2_sha256update, 1325 &__archive_libc2_sha256final, 1326#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3) 1327 &__archive_libc3_sha256init, 1328 &__archive_libc3_sha256update, 1329 &__archive_libc3_sha256final, 1330#elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD) 1331 &__archive_libmd_sha256init, 1332 &__archive_libmd_sha256update, 1333 &__archive_libmd_sha256final, 1334#elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM) 1335 &__archive_libsystem_sha256init, 1336 &__archive_libsystem_sha256update, 1337 &__archive_libsystem_sha256final, 1338#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE) 1339 &__archive_nettle_sha256init, 1340 &__archive_nettle_sha256update, 1341 &__archive_nettle_sha256final, 1342#elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL) 1343 &__archive_openssl_sha256init, 1344 &__archive_openssl_sha256update, 1345 &__archive_openssl_sha256final, 1346#elif defined(ARCHIVE_CRYPTO_SHA256_WIN) 1347 &__archive_windowsapi_sha256init, 1348 &__archive_windowsapi_sha256update, 1349 &__archive_windowsapi_sha256final, 1350#elif !defined(ARCHIVE_SHA256_COMPILE_TEST) 1351 &__archive_stub_sha256init, 1352 &__archive_stub_sha256update, 1353 &__archive_stub_sha256final, 1354#endif 1355 1356/* SHA384 */ 1357#if defined(ARCHIVE_CRYPTO_SHA384_LIBC) 1358 &__archive_libc_sha384init, 1359 &__archive_libc_sha384update, 1360 &__archive_libc_sha384final, 1361#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2) 1362 &__archive_libc2_sha384init, 1363 &__archive_libc2_sha384update, 1364 &__archive_libc2_sha384final, 1365#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3) 1366 &__archive_libc3_sha384init, 1367 &__archive_libc3_sha384update, 1368 &__archive_libc3_sha384final, 1369#elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM) 1370 &__archive_libsystem_sha384init, 1371 &__archive_libsystem_sha384update, 1372 &__archive_libsystem_sha384final, 1373#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE) 1374 &__archive_nettle_sha384init, 1375 &__archive_nettle_sha384update, 1376 &__archive_nettle_sha384final, 1377#elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL) 1378 &__archive_openssl_sha384init, 1379 &__archive_openssl_sha384update, 1380 &__archive_openssl_sha384final, 1381#elif defined(ARCHIVE_CRYPTO_SHA384_WIN) 1382 &__archive_windowsapi_sha384init, 1383 &__archive_windowsapi_sha384update, 1384 &__archive_windowsapi_sha384final, 1385#elif !defined(ARCHIVE_SHA384_COMPILE_TEST) 1386 &__archive_stub_sha384init, 1387 &__archive_stub_sha384update, 1388 &__archive_stub_sha384final, 1389#endif 1390 1391/* SHA512 */ 1392#if defined(ARCHIVE_CRYPTO_SHA512_LIBC) 1393 &__archive_libc_sha512init, 1394 &__archive_libc_sha512update, 1395 &__archive_libc_sha512final 1396#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2) 1397 &__archive_libc2_sha512init, 1398 &__archive_libc2_sha512update, 1399 &__archive_libc2_sha512final 1400#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3) 1401 &__archive_libc3_sha512init, 1402 &__archive_libc3_sha512update, 1403 &__archive_libc3_sha512final 1404#elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD) 1405 &__archive_libmd_sha512init, 1406 &__archive_libmd_sha512update, 1407 &__archive_libmd_sha512final 1408#elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM) 1409 &__archive_libsystem_sha512init, 1410 &__archive_libsystem_sha512update, 1411 &__archive_libsystem_sha512final 1412#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE) 1413 &__archive_nettle_sha512init, 1414 &__archive_nettle_sha512update, 1415 &__archive_nettle_sha512final, 1416#elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL) 1417 &__archive_openssl_sha512init, 1418 &__archive_openssl_sha512update, 1419 &__archive_openssl_sha512final 1420#elif defined(ARCHIVE_CRYPTO_SHA512_WIN) 1421 &__archive_windowsapi_sha512init, 1422 &__archive_windowsapi_sha512update, 1423 &__archive_windowsapi_sha512final 1424#elif !defined(ARCHIVE_SHA512_COMPILE_TEST) 1425 &__archive_stub_sha512init, 1426 &__archive_stub_sha512update, 1427 &__archive_stub_sha512final 1428#endif 1429}; 1430