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 EVP_DigestInit(ctx, EVP_md5()); 211 return (ARCHIVE_OK); 212 } 213 214 static 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 222 static 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 236 static int 237 __archive_windowsapi_md5init(archive_md5_ctx *ctx) 238 { 239 return (win_crypto_init(ctx, CALG_MD5)); 240 } 241 242 static 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 249 static 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 257 static int 258 __archive_stub_md5init(archive_md5_ctx *ctx) 259 { 260 (void)ctx; /* UNUSED */ 261 return (ARCHIVE_FAILED); 262 } 263 264 static 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 274 static 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 287 static int 288 __archive_libc_ripemd160init(archive_rmd160_ctx *ctx) 289 { 290 RMD160Init(ctx); 291 return (ARCHIVE_OK); 292 } 293 294 static 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 302 static 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 311 static int 312 __archive_libmd_ripemd160init(archive_rmd160_ctx *ctx) 313 { 314 RIPEMD160_Init(ctx); 315 return (ARCHIVE_OK); 316 } 317 318 static 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 326 static 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 335 static int 336 __archive_nettle_ripemd160init(archive_rmd160_ctx *ctx) 337 { 338 ripemd160_init(ctx); 339 return (ARCHIVE_OK); 340 } 341 342 static 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 350 static 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 359 static int 360 __archive_openssl_ripemd160init(archive_rmd160_ctx *ctx) 361 { 362 EVP_DigestInit(ctx, EVP_ripemd160()); 363 return (ARCHIVE_OK); 364 } 365 366 static 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 374 static 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 383 static int 384 __archive_stub_ripemd160init(archive_rmd160_ctx *ctx) 385 { 386 (void)ctx; /* UNUSED */ 387 return (ARCHIVE_FAILED); 388 } 389 390 static 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 400 static 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 413 static int 414 __archive_libc_sha1init(archive_sha1_ctx *ctx) 415 { 416 SHA1Init(ctx); 417 return (ARCHIVE_OK); 418 } 419 420 static 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 428 static 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 437 static int 438 __archive_libmd_sha1init(archive_sha1_ctx *ctx) 439 { 440 SHA1_Init(ctx); 441 return (ARCHIVE_OK); 442 } 443 444 static 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 452 static 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 461 static int 462 __archive_libsystem_sha1init(archive_sha1_ctx *ctx) 463 { 464 CC_SHA1_Init(ctx); 465 return (ARCHIVE_OK); 466 } 467 468 static 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 476 static 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 485 static int 486 __archive_nettle_sha1init(archive_sha1_ctx *ctx) 487 { 488 sha1_init(ctx); 489 return (ARCHIVE_OK); 490 } 491 492 static 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 500 static 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 509 static int 510 __archive_openssl_sha1init(archive_sha1_ctx *ctx) 511 { 512 EVP_DigestInit(ctx, EVP_sha1()); 513 return (ARCHIVE_OK); 514 } 515 516 static 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 524 static 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 538 static int 539 __archive_windowsapi_sha1init(archive_sha1_ctx *ctx) 540 { 541 return (win_crypto_init(ctx, CALG_SHA1)); 542 } 543 544 static 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 551 static 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 559 static int 560 __archive_stub_sha1init(archive_sha1_ctx *ctx) 561 { 562 (void)ctx; /* UNUSED */ 563 return (ARCHIVE_FAILED); 564 } 565 566 static 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 576 static 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 589 static int 590 __archive_libc_sha256init(archive_sha256_ctx *ctx) 591 { 592 SHA256_Init(ctx); 593 return (ARCHIVE_OK); 594 } 595 596 static 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 604 static 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 613 static int 614 __archive_libc2_sha256init(archive_sha256_ctx *ctx) 615 { 616 SHA256Init(ctx); 617 return (ARCHIVE_OK); 618 } 619 620 static 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 628 static 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 637 static int 638 __archive_libc3_sha256init(archive_sha256_ctx *ctx) 639 { 640 SHA256Init(ctx); 641 return (ARCHIVE_OK); 642 } 643 644 static 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 652 static 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 661 static int 662 __archive_libmd_sha256init(archive_sha256_ctx *ctx) 663 { 664 SHA256_Init(ctx); 665 return (ARCHIVE_OK); 666 } 667 668 static 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 676 static 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 685 static int 686 __archive_libsystem_sha256init(archive_sha256_ctx *ctx) 687 { 688 CC_SHA256_Init(ctx); 689 return (ARCHIVE_OK); 690 } 691 692 static 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 700 static 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 709 static int 710 __archive_nettle_sha256init(archive_sha256_ctx *ctx) 711 { 712 sha256_init(ctx); 713 return (ARCHIVE_OK); 714 } 715 716 static 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 724 static 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 733 static int 734 __archive_openssl_sha256init(archive_sha256_ctx *ctx) 735 { 736 EVP_DigestInit(ctx, EVP_sha256()); 737 return (ARCHIVE_OK); 738 } 739 740 static 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 748 static 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 757 static int 758 __archive_windowsapi_sha256init(archive_sha256_ctx *ctx) 759 { 760 return (win_crypto_init(ctx, CALG_SHA_256)); 761 } 762 763 static 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 770 static 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 778 static int 779 __archive_stub_sha256init(archive_sha256_ctx *ctx) 780 { 781 (void)ctx; /* UNUSED */ 782 return (ARCHIVE_FAILED); 783 } 784 785 static 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 795 static 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 808 static int 809 __archive_libc_sha384init(archive_sha384_ctx *ctx) 810 { 811 SHA384_Init(ctx); 812 return (ARCHIVE_OK); 813 } 814 815 static 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 823 static 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 832 static int 833 __archive_libc2_sha384init(archive_sha384_ctx *ctx) 834 { 835 SHA384Init(ctx); 836 return (ARCHIVE_OK); 837 } 838 839 static 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 847 static 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 856 static int 857 __archive_libc3_sha384init(archive_sha384_ctx *ctx) 858 { 859 SHA384Init(ctx); 860 return (ARCHIVE_OK); 861 } 862 863 static 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 871 static 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 880 static int 881 __archive_libsystem_sha384init(archive_sha384_ctx *ctx) 882 { 883 CC_SHA384_Init(ctx); 884 return (ARCHIVE_OK); 885 } 886 887 static 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 895 static 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 904 static int 905 __archive_nettle_sha384init(archive_sha384_ctx *ctx) 906 { 907 sha384_init(ctx); 908 return (ARCHIVE_OK); 909 } 910 911 static 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 919 static 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 928 static int 929 __archive_openssl_sha384init(archive_sha384_ctx *ctx) 930 { 931 EVP_DigestInit(ctx, EVP_sha384()); 932 return (ARCHIVE_OK); 933 } 934 935 static 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 943 static 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 952 static int 953 __archive_windowsapi_sha384init(archive_sha384_ctx *ctx) 954 { 955 return (win_crypto_init(ctx, CALG_SHA_384)); 956 } 957 958 static 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 965 static 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 973 static int 974 __archive_stub_sha384init(archive_sha384_ctx *ctx) 975 { 976 (void)ctx; /* UNUSED */ 977 return (ARCHIVE_FAILED); 978 } 979 980 static 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 990 static 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 1003 static int 1004 __archive_libc_sha512init(archive_sha512_ctx *ctx) 1005 { 1006 SHA512_Init(ctx); 1007 return (ARCHIVE_OK); 1008 } 1009 1010 static 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 1018 static 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 1027 static int 1028 __archive_libc2_sha512init(archive_sha512_ctx *ctx) 1029 { 1030 SHA512Init(ctx); 1031 return (ARCHIVE_OK); 1032 } 1033 1034 static 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 1042 static 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 1051 static int 1052 __archive_libc3_sha512init(archive_sha512_ctx *ctx) 1053 { 1054 SHA512Init(ctx); 1055 return (ARCHIVE_OK); 1056 } 1057 1058 static 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 1066 static 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 1075 static int 1076 __archive_libmd_sha512init(archive_sha512_ctx *ctx) 1077 { 1078 SHA512_Init(ctx); 1079 return (ARCHIVE_OK); 1080 } 1081 1082 static 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 1090 static 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 1099 static int 1100 __archive_libsystem_sha512init(archive_sha512_ctx *ctx) 1101 { 1102 CC_SHA512_Init(ctx); 1103 return (ARCHIVE_OK); 1104 } 1105 1106 static 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 1114 static 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 1123 static int 1124 __archive_nettle_sha512init(archive_sha512_ctx *ctx) 1125 { 1126 sha512_init(ctx); 1127 return (ARCHIVE_OK); 1128 } 1129 1130 static 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 1138 static 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 1147 static int 1148 __archive_openssl_sha512init(archive_sha512_ctx *ctx) 1149 { 1150 EVP_DigestInit(ctx, EVP_sha512()); 1151 return (ARCHIVE_OK); 1152 } 1153 1154 static 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 1162 static 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 1171 static int 1172 __archive_windowsapi_sha512init(archive_sha512_ctx *ctx) 1173 { 1174 return (win_crypto_init(ctx, CALG_SHA_512)); 1175 } 1176 1177 static 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 1184 static 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 1192 static int 1193 __archive_stub_sha512init(archive_sha512_ctx *ctx) 1194 { 1195 (void)ctx; /* UNUSED */ 1196 return (ARCHIVE_FAILED); 1197 } 1198 1199 static 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 1209 static 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: Message Digest functions are set based on availability and by the 1220 * following 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 */ 1230 const struct archive_digest __archive_digest = 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