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